Boomerang: pentiumdecoder.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 1 "frontend/machine/pentium/decoder.m"
00005 /*
00006  * Copyright (C) 1998-2001, The University of Queensland
00007  *
00008  * See the file "LICENSE.TERMS" for information on usage and
00009  * redistribution of this file, and for a DISCLAIMER OF ALL
00010  * WARRANTIES.
00011  *
00012  */
00013 
00014 /*==============================================================================
00015  * FILE:       decoder.m
00016  * OVERVIEW:   This file contains the high level decoding functionality, for example matching logues, calls, branches,
00017  *              etc. Ordinary instructions are processed in decoder_low.m
00018  *============================================================================*/ 
00019 /*
00020  * $Revision: 1.66 $    // 1.33.2.2
00021  *
00022  * 26 Apr 02 - Mike: Changes for boomerang
00023  * 18 Nov 02 - Mike: Mods for MOV.Ed.Iv^od etc. Also suppressed warning re name
00024  * 09 Dec 02 - Mike: Changed DIS_REG32 to use dis_Reg again, because in the
00025  *              SSL file we have reg32 instead of r[reg32] (compat with SPARC)
00026  * 07 May 03 - Mike: Fixed several arithmetic and logical "iodb" instructions
00027  *              that had 8 bit instead of 32 bit modrm sizes
00028  * 24 Oct 03 - Mike: Fixed DIS_IDXP1: did not have +32 in macro
00029  * 02 Sep 05 - Mike: POP.Evod/w take Eaddr now, not Mem
00030 */
00031 
00032 #include <assert.h>
00033 #if defined(_MSC_VER) && _MSC_VER <= 1100
00034 #include "signature.h"
00035 #endif
00036 
00037 #include "rtl.h"
00038 #include "decoder.h"
00039 #include "pentiumdecoder.h"
00040 #include "prog.h"
00041 #include "exp.h"
00042 #include "proc.h"
00043 #include "boomerang.h"
00044 #include "statement.h"
00045 
00046 #define DIS_R8    (dis_Reg(r8+8))
00047 #define DIS_R16   (dis_Reg(r16+0))
00048 #define DIS_R32   (dis_Reg(r32+24))
00049 #define DIS_REG8  (dis_Reg(reg+8))
00050 #define DIS_REG16 (dis_Reg(reg+0))
00051 #define DIS_REG32 (dis_Reg(reg+24))
00052 #define DIS_SR16  (dis_Reg(sr16+16))
00053 #define DIS_IDX   (dis_Reg(idx+32))
00054 #define DIS_IDXP1 (dis_Reg((idx+1)%7+32))
00055 
00056 #define DIS_EADDR32 (dis_Eaddr(Eaddr, 32))
00057 #define DIS_EADDR16 (dis_Eaddr(Eaddr, 16))
00058 #define DIS_EADDR8  (dis_Eaddr(Eaddr,  8))
00059 #define DIS_MEM     (dis_Mem(Mem))
00060 #define DIS_MEM16   (dis_Mem(Mem16))    // Probably needs changing
00061 #define DIS_MEM32   (dis_Mem(Mem32))    // Probably needs changing
00062 #define DIS_MEM64   (dis_Mem(Mem64))    // Probably needs changing
00063 #define DIS_MEM80   (dis_Mem(Mem80))    // Probably needs changing
00064 
00065 #define DIS_I32     (addReloc(new Const(i32)))
00066 #define DIS_I16     (new Const(i16))
00067 #define DIS_I8      (new Const(i8))
00068 #define DIS_COUNT   (new Const(count))
00069 #define DIS_OFF     (addReloc(new Const(off)))
00070 
00071 
00072 // Function to generate statements for the BSF/BSR series (Bit Scan Forward/
00073 // Reverse)
00074 void genBSFR(ADDRESS pc, Exp* reg, Exp* modrm, int init, int size, OPER incdec,
00075     int numBytes);
00076 
00077 /**********************************
00078  * PentiumDecoder methods.
00079  **********************************/   
00080 
00081 /*==============================================================================
00082  * FUNCTION:       unused
00083  * OVERVIEW:       A dummy function to suppress "unused local variable" messages
00084  * PARAMETERS:     x: integer variable to be "used"
00085  * RETURNS:        Nothing
00086  *============================================================================*/
00087 void PentiumDecoder::unused(int x)
00088 {}
00089 
00090 /*==============================================================================
00091  * FUNCTION:       PentiumDecoder::decodeInstruction
00092  * OVERVIEW:       Decodes a machine instruction and returns an RTL instance. In most cases a single instruction is
00093  *                  decoded. However, if a higher level construct that may consist of multiple instructions is matched,
00094  *                  then there may be a need to return more than one RTL. The caller_prologue2 is an example of such
00095  *                  a construct which encloses an abritary instruction that must be decoded into its own RTL.
00096  * PARAMETERS:     pc - the native address of the pc
00097  *                 delta - the difference between the above address and the host address of the pc (i.e. the address
00098  *                  that the pc is at in the loaded object file)
00099  *                 RTLDict - the dictionary of RTL templates used to instantiate the RTL for the instruction being
00100  *                  decoded
00101  *                 proc - the enclosing procedure
00102  * RETURNS:        a DecodeResult structure containing all the information gathered during decoding
00103  *============================================================================*/
00104 static DecodeResult result;
00105 DecodeResult& PentiumDecoder::decodeInstruction (ADDRESS pc, int delta)
00106 {
00107     ADDRESS hostPC = pc + delta;
00108 
00109     // Clear the result structure;
00110     result.reset();
00111 
00112     // The actual list of instantiated Statements
00113     std::list<Statement*>* stmts = NULL;
00114 
00115 
00116     ADDRESS nextPC = NO_ADDRESS;
00117 
00118 
00119 #line 112 "frontend/machine/pentium/decoder.m"
00120 { 
00121   dword MATCH_p = 
00122     
00123 #line 112 "frontend/machine/pentium/decoder.m"
00124     hostPC
00125     ;
00126   char *MATCH_name;
00127   char *MATCH_name_page_0[] = {"REPNE.MOVSB", "JMP.Jvow", };
00128   char *MATCH_name_page_1[] = {"REPNE.MOVSvow", "REPNE.STOSvow", };
00129   char *MATCH_name_page_2[] = {"REPNE.CMPSvow", "REPNE.LODSvow", };
00130   char *MATCH_name_page_3[] = {"REP.MOVSvow", "REPNE.SCASvow", };
00131   char *MATCH_name_page_4[] = {"REPNE.MOVSvod", "REPNE.STOSB", };
00132   char *MATCH_name_page_5[] = {"REPNE.CMPSB", "REPNE.STOSvod", };
00133   char *MATCH_name_page_6[] = {"REPNE.CMPSvod", "REPNE.LODSB", };
00134   char *MATCH_name_page_7[] = {"REP.MOVSB", "REPNE.LODSvod", };
00135   char *MATCH_name_page_8[] = {"REP.MOVSvod", "REPNE.SCASB", };
00136   char *MATCH_name_page_9[] = {"REP.CMPSB", "REPNE.SCASvod", };
00137   char *MATCH_name_page_10[] = {"REP.CMPSvow", "REP.STOSvow", };
00138   char *MATCH_name_page_13[] = {"REP.CMPSvod", "REP.STOSB", };
00139   char *MATCH_name_col_59[] = {(char *)0, "JMP.Jvod", (char *)0, "JMP.Jb", };
00140   unsigned /* [0..255] */ MATCH_w_8_0;
00141   unsigned /* [0..255] */ MATCH_w_8_8;
00142   unsigned /* [0..65535] */ MATCH_w_16_8;
00143   unsigned MATCH_w_32_8;
00144   unsigned /* [0..255] */ MATCH_w_8_16;
00145   unsigned /* [0..65535] */ MATCH_w_16_16;
00146   unsigned MATCH_w_32_16;
00147   unsigned /* [0..255] */ MATCH_w_8_24;
00148   unsigned /* [0..65535] */ MATCH_w_16_24;
00149   unsigned MATCH_w_32_24;
00150   unsigned /* [0..255] */ MATCH_w_8_32;
00151   unsigned /* [0..65535] */ MATCH_w_16_32;
00152   unsigned MATCH_w_32_32;
00153   unsigned /* [0..255] */ MATCH_w_8_40;
00154   unsigned /* [0..65535] */ MATCH_w_16_40;
00155   unsigned /* [0..255] */ MATCH_w_8_48;
00156   unsigned MATCH_w_32_48;
00157   unsigned /* [0..255] */ MATCH_w_8_56;
00158   unsigned /* [0..65535] */ MATCH_w_16_56;
00159   unsigned MATCH_w_32_56;
00160   unsigned /* [0..255] */ MATCH_w_8_64;
00161   unsigned /* [0..65535] */ MATCH_w_16_64;
00162   unsigned /* [0..255] */ MATCH_w_8_72;
00163   { 
00164     MATCH_w_8_0 = getByte(MATCH_p); 
00165     if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) 
00166       
00167         switch((MATCH_w_8_0 >> 4 & 0xf) /* row at 0 */) {
00168           case 0: 
00169             
00170               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
00171                 case 0: 
00172                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
00173                   
00174                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
00175                       case 0: 
00176                         
00177                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
00178                             case 0: case 1: case 2: case 3: case 6: case 7: 
00179                               goto MATCH_label_c786; break;
00180                             case 4: 
00181                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
00182                               if ((MATCH_w_8_16 & 0x7) 
00183                                       /* base at 16 */ == 5 && 
00184                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00185                                       /* index at 16 */ && 
00186                                 (MATCH_w_8_16 >> 3 & 0x7) 
00187                                       /* index at 16 */ < 8)) 
00188                                 goto MATCH_label_c788;  /*opt-block+*/
00189                               else 
00190                                 goto MATCH_label_c787;  /*opt-block+*/
00191                               
00192                               break;
00193                             case 5: 
00194                               goto MATCH_label_c789; break;
00195                             default: assert(0);
00196                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
00197                         break;
00198                       case 1: 
00199                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
00200                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
00201                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00202                                 /* index at 16 */ && 
00203                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
00204                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
00205                           unsigned r8 = 
00206                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
00207                           nextPC = 4 + MATCH_p; 
00208                           
00209 #line 1543 "frontend/machine/pentium/decoder.m"
00210                           
00211 
00212                                 stmts = instantiate(pc,  "ORmrb", DIS_EADDR8, DIS_R8);
00213 
00214                           
00215 
00216                           
00217                           
00218                           
00219                         } /*opt-block*//*opt-block+*/
00220                         else 
00221                           goto MATCH_label_c787;  /*opt-block+*/
00222                         
00223                         break;
00224                       case 2: 
00225                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
00226                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
00227                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00228                                 /* index at 16 */ && 
00229                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
00230                           goto MATCH_label_c788;  /*opt-block+*/
00231                         else 
00232                           goto MATCH_label_c789;  /*opt-block+*/
00233                         
00234                         break;
00235                       case 3: 
00236                         goto MATCH_label_c786; break;
00237                       default: assert(0);
00238                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
00239                   
00240                   break;
00241                 case 1: 
00242                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
00243                   
00244                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
00245                       case 0: 
00246                         
00247                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
00248                             case 0: case 1: case 2: case 3: case 6: case 7: 
00249                               goto MATCH_label_c790; break;
00250                             case 4: 
00251                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
00252                               if ((MATCH_w_8_16 & 0x7) 
00253                                       /* base at 16 */ == 5 && 
00254                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00255                                       /* index at 16 */ && 
00256                                 (MATCH_w_8_16 >> 3 & 0x7) 
00257                                       /* index at 16 */ < 8)) 
00258                                 goto MATCH_label_c792;  /*opt-block+*/
00259                               else 
00260                                 goto MATCH_label_c791;  /*opt-block+*/
00261                               
00262                               break;
00263                             case 5: 
00264                               goto MATCH_label_c793; break;
00265                             default: assert(0);
00266                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
00267                         break;
00268                       case 1: 
00269                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
00270                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
00271                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00272                                 /* index at 16 */ && 
00273                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
00274                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
00275                           unsigned reg = 
00276                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
00277                           nextPC = 4 + MATCH_p; 
00278                           
00279 #line 1513 "frontend/machine/pentium/decoder.m"
00280                           
00281 
00282                                 stmts = instantiate(pc,  "ORmrod", DIS_EADDR32, DIS_REG32);
00283 
00284                           
00285 
00286                           
00287                           
00288                           
00289                         } /*opt-block*//*opt-block+*/
00290                         else 
00291                           goto MATCH_label_c791;  /*opt-block+*/
00292                         
00293                         break;
00294                       case 2: 
00295                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
00296                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
00297                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00298                                 /* index at 16 */ && 
00299                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
00300                           goto MATCH_label_c792;  /*opt-block+*/
00301                         else 
00302                           goto MATCH_label_c793;  /*opt-block+*/
00303                         
00304                         break;
00305                       case 3: 
00306                         goto MATCH_label_c790; break;
00307                       default: assert(0);
00308                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
00309                   
00310                   break;
00311                 case 2: 
00312                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
00313                   
00314                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
00315                       case 0: 
00316                         
00317                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
00318                             case 0: case 1: case 2: case 3: case 6: case 7: 
00319                               goto MATCH_label_c794; break;
00320                             case 4: 
00321                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
00322                               if ((MATCH_w_8_16 & 0x7) 
00323                                       /* base at 16 */ == 5 && 
00324                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00325                                       /* index at 16 */ && 
00326                                 (MATCH_w_8_16 >> 3 & 0x7) 
00327                                       /* index at 16 */ < 8)) 
00328                                 goto MATCH_label_c796;  /*opt-block+*/
00329                               else 
00330                                 goto MATCH_label_c795;  /*opt-block+*/
00331                               
00332                               break;
00333                             case 5: 
00334                               goto MATCH_label_c797; break;
00335                             default: assert(0);
00336                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
00337                         break;
00338                       case 1: 
00339                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
00340                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
00341                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00342                                 /* index at 16 */ && 
00343                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
00344                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
00345                           unsigned r8 = 
00346                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
00347                           nextPC = 4 + MATCH_p; 
00348                           
00349 #line 1471 "frontend/machine/pentium/decoder.m"
00350                           
00351 
00352                                 stmts = instantiate(pc,  "ORrmb", DIS_R8, DIS_EADDR8);
00353 
00354                           
00355 
00356                           
00357                           
00358                           
00359                         } /*opt-block*//*opt-block+*/
00360                         else 
00361                           goto MATCH_label_c795;  /*opt-block+*/
00362                         
00363                         break;
00364                       case 2: 
00365                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
00366                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
00367                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00368                                 /* index at 16 */ && 
00369                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
00370                           goto MATCH_label_c796;  /*opt-block+*/
00371                         else 
00372                           goto MATCH_label_c797;  /*opt-block+*/
00373                         
00374                         break;
00375                       case 3: 
00376                         goto MATCH_label_c794; break;
00377                       default: assert(0);
00378                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
00379                   
00380                   break;
00381                 case 3: 
00382                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
00383                   
00384                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
00385                       case 0: 
00386                         
00387                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
00388                             case 0: case 1: case 2: case 3: case 6: case 7: 
00389                               goto MATCH_label_c798; break;
00390                             case 4: 
00391                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
00392                               if ((MATCH_w_8_16 & 0x7) 
00393                                       /* base at 16 */ == 5 && 
00394                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00395                                       /* index at 16 */ && 
00396                                 (MATCH_w_8_16 >> 3 & 0x7) 
00397                                       /* index at 16 */ < 8)) 
00398                                 goto MATCH_label_c800;  /*opt-block+*/
00399                               else 
00400                                 goto MATCH_label_c799;  /*opt-block+*/
00401                               
00402                               break;
00403                             case 5: 
00404                               goto MATCH_label_c801; break;
00405                             default: assert(0);
00406                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
00407                         break;
00408                       case 1: 
00409                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
00410                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
00411                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00412                                 /* index at 16 */ && 
00413                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
00414                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
00415                           unsigned reg = 
00416                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
00417                           nextPC = 4 + MATCH_p; 
00418                           
00419 #line 1441 "frontend/machine/pentium/decoder.m"
00420                           
00421 
00422                                 stmts = instantiate(pc,  "ORrmod", DIS_REG32, DIS_EADDR32);
00423 
00424                           
00425 
00426                           
00427                           
00428                           
00429                         } /*opt-block*//*opt-block+*/
00430                         else 
00431                           goto MATCH_label_c799;  /*opt-block+*/
00432                         
00433                         break;
00434                       case 2: 
00435                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
00436                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
00437                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00438                                 /* index at 16 */ && 
00439                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
00440                           goto MATCH_label_c800;  /*opt-block+*/
00441                         else 
00442                           goto MATCH_label_c801;  /*opt-block+*/
00443                         
00444                         break;
00445                       case 3: 
00446                         goto MATCH_label_c798; break;
00447                       default: assert(0);
00448                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
00449                   
00450                   break;
00451                 case 4: 
00452                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
00453                   { 
00454                     int /* [~128..127] */ i8 = 
00455                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
00456                     nextPC = 2 + MATCH_p; 
00457                     
00458 #line 1738 "frontend/machine/pentium/decoder.m"
00459                     
00460 
00461                             stmts = instantiate(pc,  "ORiAL", DIS_I8);
00462 
00463                     
00464 
00465                     
00466                     
00467                     
00468                   }
00469                   
00470                   break;
00471                 case 5: 
00472                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
00473                   { 
00474                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
00475                     nextPC = 5 + MATCH_p; 
00476                     
00477 #line 1690 "frontend/machine/pentium/decoder.m"
00478                     
00479 
00480                             stmts = instantiate(pc,  "ORiEAX", DIS_I32);
00481 
00482                     
00483 
00484                     
00485                     
00486                     
00487                   }
00488                   
00489                   break;
00490                 case 6: 
00491                   nextPC = 1 + MATCH_p; 
00492                   
00493 #line 817 "frontend/machine/pentium/decoder.m"
00494                   
00495 
00496                         stmts = instantiate(pc,  "PUSH.CS");
00497 
00498                   
00499 
00500                   
00501                   
00502                   
00503                   
00504                   break;
00505                 case 7: 
00506                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
00507                   
00508                     switch((MATCH_w_8_8 >> 4 & 0xf) /* row at 8 */) {
00509                       case 0: 
00510                         
00511                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
00512                             case 0: 
00513                               if ((MATCH_w_8_8 >> 3 & 0x1) 
00514                                       /* page at 8 */ == 1) { 
00515                                 nextPC = 2 + MATCH_p; 
00516                                 
00517 #line 1098 "frontend/machine/pentium/decoder.m"
00518                                 
00519 
00520                                         stmts = instantiate(pc,  "INVD");
00521 
00522                                 
00523 
00524                                 
00525                                 
00526                                 
00527                               } /*opt-block*//*opt-block+*/
00528                               else { 
00529                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
00530                                 
00531                                   switch((MATCH_w_8_16 >> 3 & 0x7) 
00532                                         /* reg_opcode at 16 */) {
00533                                     case 0: 
00534                                       
00535                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
00536                                               /* mod at 16 */) {
00537                                           case 0: 
00538                                             
00539                                               switch((MATCH_w_8_16 & 0x7) 
00540                                                     /* r_m at 16 */) {
00541                                                 case 0: case 1: case 2: 
00542                                                 case 3: case 6: case 7: 
00543                                                   goto MATCH_label_c802; 
00544                                                   
00545                                                   break;
00546                                                 case 4: 
00547                                                   MATCH_w_8_24 = 
00548                                                     getByte(3 + MATCH_p); 
00549                                                   if ((MATCH_w_8_24 & 0x7) 
00550                                                           /* base at 24 */ == 5 && 
00551                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00552                                                           /* index at 24 */ && 
00553                                                     (MATCH_w_8_24 >> 3 & 0x7) 
00554                                                           /* index at 24 */ < 8)) 
00555                                                     goto MATCH_label_c804;  /*opt-block+*/
00556                                                   else 
00557                                                     goto MATCH_label_c803;  /*opt-block+*/
00558                                                   
00559                                                   break;
00560                                                 case 5: 
00561                                                   goto MATCH_label_c805; 
00562                                                   
00563                                                   break;
00564                                                 default: assert(0);
00565                                               } /* (MATCH_w_8_16 & 0x7) 
00566                                                     -- r_m at 16 --*/ 
00567                                             break;
00568                                           case 1: 
00569                                             MATCH_w_8_24 = 
00570                                               getByte(3 + MATCH_p); 
00571                                             if ((MATCH_w_8_16 & 0x7) 
00572                                                     /* r_m at 16 */ == 4 && 
00573                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00574                                                     /* index at 24 */ && 
00575                                               (MATCH_w_8_24 >> 3 & 0x7) 
00576                                                     /* index at 24 */ < 8)) { 
00577                                               unsigned Eaddr = 
00578                                                 2 + addressToPC(MATCH_p);
00579                                               nextPC = 5 + MATCH_p; 
00580                                               
00581 #line 429 "frontend/machine/pentium/decoder.m"
00582                                               
00583 
00584                                                     stmts = instantiate(pc,  "SLDT", DIS_EADDR32);
00585 
00586                                               
00587 
00588                                               
00589                                               
00590                                               
00591                                             } /*opt-block*//*opt-block+*/
00592                                             else 
00593                                               goto MATCH_label_c803;  /*opt-block+*/
00594                                             
00595                                             break;
00596                                           case 2: 
00597                                             MATCH_w_8_24 = 
00598                                               getByte(3 + MATCH_p); 
00599                                             if ((MATCH_w_8_16 & 0x7) 
00600                                                     /* r_m at 16 */ == 4 && 
00601                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00602                                                     /* index at 24 */ && 
00603                                               (MATCH_w_8_24 >> 3 & 0x7) 
00604                                                     /* index at 24 */ < 8)) 
00605                                               goto MATCH_label_c804;  /*opt-block+*/
00606                                             else 
00607                                               goto MATCH_label_c805;  /*opt-block+*/
00608                                             
00609                                             break;
00610                                           case 3: 
00611                                             goto MATCH_label_c802; break;
00612                                           default: assert(0);
00613                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
00614                                               -- mod at 16 --*/ 
00615                                       break;
00616                                     case 1: 
00617                                       
00618                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
00619                                               /* mod at 16 */) {
00620                                           case 0: 
00621                                             
00622                                               switch((MATCH_w_8_16 & 0x7) 
00623                                                     /* r_m at 16 */) {
00624                                                 case 0: case 1: case 2: 
00625                                                 case 3: case 6: case 7: 
00626                                                   { 
00627                                                     unsigned Mem = 
00628                                                       2 + 
00629                                                       addressToPC(MATCH_p);
00630                                                     nextPC = 3 + MATCH_p; 
00631                                                     
00632 #line 405 "frontend/machine/pentium/decoder.m"
00633                                                     
00634 
00635                                                             stmts = instantiate(pc,  "STR", DIS_MEM);
00636 
00637                                                     
00638 
00639                                                     
00640                                                     
00641                                                     
00642                                                   }
00643                                                   
00644                                                   break;
00645                                                 case 4: 
00646                                                   MATCH_w_8_24 = 
00647                                                     getByte(3 + MATCH_p); 
00648                                                   if ((MATCH_w_8_24 & 0x7) 
00649                                                           /* base at 24 */ == 5 && 
00650                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00651                                                           /* index at 24 */ && 
00652                                                     (MATCH_w_8_24 >> 3 & 0x7) 
00653                                                           /* index at 24 */ < 8)) 
00654                                                     goto MATCH_label_c807;  /*opt-block+*/
00655                                                   else 
00656                                                     goto MATCH_label_c806;  /*opt-block+*/
00657                                                   
00658                                                   break;
00659                                                 case 5: 
00660                                                   goto MATCH_label_c808; 
00661                                                   
00662                                                   break;
00663                                                 default: assert(0);
00664                                               } /* (MATCH_w_8_16 & 0x7) 
00665                                                     -- r_m at 16 --*/ 
00666                                             break;
00667                                           case 1: 
00668                                             MATCH_w_8_24 = 
00669                                               getByte(3 + MATCH_p); 
00670                                             if ((MATCH_w_8_16 & 0x7) 
00671                                                     /* r_m at 16 */ == 4 && 
00672                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00673                                                     /* index at 24 */ && 
00674                                               (MATCH_w_8_24 >> 3 & 0x7) 
00675                                                     /* index at 24 */ < 8)) { 
00676                                               unsigned Mem = 
00677                                                 2 + addressToPC(MATCH_p);
00678                                               nextPC = 5 + MATCH_p; 
00679                                               
00680 #line 405 "frontend/machine/pentium/decoder.m"
00681                                               
00682 
00683                                                     stmts = instantiate(pc,  "STR", DIS_MEM);
00684 
00685                                               
00686 
00687                                               
00688                                               
00689                                               
00690                                             } /*opt-block*//*opt-block+*/
00691                                             else 
00692                                               goto MATCH_label_c806;  /*opt-block+*/
00693                                             
00694                                             break;
00695                                           case 2: 
00696                                             MATCH_w_8_24 = 
00697                                               getByte(3 + MATCH_p); 
00698                                             if ((MATCH_w_8_16 & 0x7) 
00699                                                     /* r_m at 16 */ == 4 && 
00700                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00701                                                     /* index at 24 */ && 
00702                                               (MATCH_w_8_24 >> 3 & 0x7) 
00703                                                     /* index at 24 */ < 8)) 
00704                                               goto MATCH_label_c807;  /*opt-block+*/
00705                                             else 
00706                                               goto MATCH_label_c808;  /*opt-block+*/
00707                                             
00708                                             break;
00709                                           case 3: 
00710                                             goto MATCH_label_c64; break;
00711                                           default: assert(0);
00712                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
00713                                               -- mod at 16 --*/ 
00714                                       break;
00715                                     case 2: case 6: case 7: 
00716                                       goto MATCH_label_c64; break;
00717                                     case 3: 
00718                                       
00719                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
00720                                               /* mod at 16 */) {
00721                                           case 0: 
00722                                             
00723                                               switch((MATCH_w_8_16 & 0x7) 
00724                                                     /* r_m at 16 */) {
00725                                                 case 0: case 1: case 2: 
00726                                                 case 3: case 6: case 7: 
00727                                                   goto MATCH_label_c809; 
00728                                                   
00729                                                   break;
00730                                                 case 4: 
00731                                                   MATCH_w_8_24 = 
00732                                                     getByte(3 + MATCH_p); 
00733                                                   if ((MATCH_w_8_24 & 0x7) 
00734                                                           /* base at 24 */ == 5 && 
00735                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00736                                                           /* index at 24 */ && 
00737                                                     (MATCH_w_8_24 >> 3 & 0x7) 
00738                                                           /* index at 24 */ < 8)) 
00739                                                     goto MATCH_label_c811;  /*opt-block+*/
00740                                                   else 
00741                                                     goto MATCH_label_c810;  /*opt-block+*/
00742                                                   
00743                                                   break;
00744                                                 case 5: 
00745                                                   goto MATCH_label_c812; 
00746                                                   
00747                                                   break;
00748                                                 default: assert(0);
00749                                               } /* (MATCH_w_8_16 & 0x7) 
00750                                                     -- r_m at 16 --*/ 
00751                                             break;
00752                                           case 1: 
00753                                             MATCH_w_8_24 = 
00754                                               getByte(3 + MATCH_p); 
00755                                             if ((MATCH_w_8_16 & 0x7) 
00756                                                     /* r_m at 16 */ == 4 && 
00757                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00758                                                     /* index at 24 */ && 
00759                                               (MATCH_w_8_24 >> 3 & 0x7) 
00760                                                     /* index at 24 */ < 8)) { 
00761                                               unsigned Eaddr = 
00762                                                 2 + addressToPC(MATCH_p);
00763                                               nextPC = 5 + MATCH_p; 
00764                                               
00765 #line 1040 "frontend/machine/pentium/decoder.m"
00766                                               
00767 
00768                                                     stmts = instantiate(pc,  "LTR", DIS_EADDR32);
00769 
00770                                               
00771 
00772                                               
00773                                               
00774                                               
00775                                             } /*opt-block*//*opt-block+*/
00776                                             else 
00777                                               goto MATCH_label_c810;  /*opt-block+*/
00778                                             
00779                                             break;
00780                                           case 2: 
00781                                             MATCH_w_8_24 = 
00782                                               getByte(3 + MATCH_p); 
00783                                             if ((MATCH_w_8_16 & 0x7) 
00784                                                     /* r_m at 16 */ == 4 && 
00785                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00786                                                     /* index at 24 */ && 
00787                                               (MATCH_w_8_24 >> 3 & 0x7) 
00788                                                     /* index at 24 */ < 8)) 
00789                                               goto MATCH_label_c811;  /*opt-block+*/
00790                                             else 
00791                                               goto MATCH_label_c812;  /*opt-block+*/
00792                                             
00793                                             break;
00794                                           case 3: 
00795                                             goto MATCH_label_c809; break;
00796                                           default: assert(0);
00797                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
00798                                               -- mod at 16 --*/ 
00799                                       break;
00800                                     case 4: 
00801                                       
00802                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
00803                                               /* mod at 16 */) {
00804                                           case 0: 
00805                                             
00806                                               switch((MATCH_w_8_16 & 0x7) 
00807                                                     /* r_m at 16 */) {
00808                                                 case 0: case 1: case 2: 
00809                                                 case 3: case 6: case 7: 
00810                                                   goto MATCH_label_c813; 
00811                                                   
00812                                                   break;
00813                                                 case 4: 
00814                                                   MATCH_w_8_24 = 
00815                                                     getByte(3 + MATCH_p); 
00816                                                   if ((MATCH_w_8_24 & 0x7) 
00817                                                           /* base at 24 */ == 5 && 
00818                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00819                                                           /* index at 24 */ && 
00820                                                     (MATCH_w_8_24 >> 3 & 0x7) 
00821                                                           /* index at 24 */ < 8)) 
00822                                                     goto MATCH_label_c815;  /*opt-block+*/
00823                                                   else 
00824                                                     goto MATCH_label_c814;  /*opt-block+*/
00825                                                   
00826                                                   break;
00827                                                 case 5: 
00828                                                   goto MATCH_label_c816; 
00829                                                   
00830                                                   break;
00831                                                 default: assert(0);
00832                                               } /* (MATCH_w_8_16 & 0x7) 
00833                                                     -- r_m at 16 --*/ 
00834                                             break;
00835                                           case 1: 
00836                                             MATCH_w_8_24 = 
00837                                               getByte(3 + MATCH_p); 
00838                                             if ((MATCH_w_8_16 & 0x7) 
00839                                                     /* r_m at 16 */ == 4 && 
00840                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00841                                                     /* index at 24 */ && 
00842                                               (MATCH_w_8_24 >> 3 & 0x7) 
00843                                                     /* index at 24 */ < 8)) { 
00844                                               unsigned Eaddr = 
00845                                                 2 + addressToPC(MATCH_p);
00846                                               nextPC = 5 + MATCH_p; 
00847                                               
00848 #line 375 "frontend/machine/pentium/decoder.m"
00849                                               
00850 
00851                                                     stmts = instantiate(pc,  "VERR", DIS_EADDR32);
00852 
00853                                               
00854 
00855                                               
00856                                               
00857                                               
00858                                             } /*opt-block*//*opt-block+*/
00859                                             else 
00860                                               goto MATCH_label_c814;  /*opt-block+*/
00861                                             
00862                                             break;
00863                                           case 2: 
00864                                             MATCH_w_8_24 = 
00865                                               getByte(3 + MATCH_p); 
00866                                             if ((MATCH_w_8_16 & 0x7) 
00867                                                     /* r_m at 16 */ == 4 && 
00868                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00869                                                     /* index at 24 */ && 
00870                                               (MATCH_w_8_24 >> 3 & 0x7) 
00871                                                     /* index at 24 */ < 8)) 
00872                                               goto MATCH_label_c815;  /*opt-block+*/
00873                                             else 
00874                                               goto MATCH_label_c816;  /*opt-block+*/
00875                                             
00876                                             break;
00877                                           case 3: 
00878                                             goto MATCH_label_c813; break;
00879                                           default: assert(0);
00880                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
00881                                               -- mod at 16 --*/ 
00882                                       break;
00883                                     case 5: 
00884                                       
00885                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
00886                                               /* mod at 16 */) {
00887                                           case 0: 
00888                                             
00889                                               switch((MATCH_w_8_16 & 0x7) 
00890                                                     /* r_m at 16 */) {
00891                                                 case 0: case 1: case 2: 
00892                                                 case 3: case 6: case 7: 
00893                                                   goto MATCH_label_c817; 
00894                                                   
00895                                                   break;
00896                                                 case 4: 
00897                                                   MATCH_w_8_24 = 
00898                                                     getByte(3 + MATCH_p); 
00899                                                   if ((MATCH_w_8_24 & 0x7) 
00900                                                           /* base at 24 */ == 5 && 
00901                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00902                                                           /* index at 24 */ && 
00903                                                     (MATCH_w_8_24 >> 3 & 0x7) 
00904                                                           /* index at 24 */ < 8)) 
00905                                                     goto MATCH_label_c819;  /*opt-block+*/
00906                                                   else 
00907                                                     goto MATCH_label_c818;  /*opt-block+*/
00908                                                   
00909                                                   break;
00910                                                 case 5: 
00911                                                   goto MATCH_label_c820; 
00912                                                   
00913                                                   break;
00914                                                 default: assert(0);
00915                                               } /* (MATCH_w_8_16 & 0x7) 
00916                                                     -- r_m at 16 --*/ 
00917                                             break;
00918                                           case 1: 
00919                                             MATCH_w_8_24 = 
00920                                               getByte(3 + MATCH_p); 
00921                                             if ((MATCH_w_8_16 & 0x7) 
00922                                                     /* r_m at 16 */ == 4 && 
00923                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00924                                                     /* index at 24 */ && 
00925                                               (MATCH_w_8_24 >> 3 & 0x7) 
00926                                                     /* index at 24 */ < 8)) { 
00927                                               unsigned Eaddr = 
00928                                                 2 + addressToPC(MATCH_p);
00929                                               nextPC = 5 + MATCH_p; 
00930                                               
00931 #line 372 "frontend/machine/pentium/decoder.m"
00932                                               
00933 
00934                                                     stmts = instantiate(pc,  "VERW", DIS_EADDR32);
00935 
00936                                               
00937 
00938                                               
00939                                               
00940                                               
00941                                             } /*opt-block*//*opt-block+*/
00942                                             else 
00943                                               goto MATCH_label_c818;  /*opt-block+*/
00944                                             
00945                                             break;
00946                                           case 2: 
00947                                             MATCH_w_8_24 = 
00948                                               getByte(3 + MATCH_p); 
00949                                             if ((MATCH_w_8_16 & 0x7) 
00950                                                     /* r_m at 16 */ == 4 && 
00951                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00952                                                     /* index at 24 */ && 
00953                                               (MATCH_w_8_24 >> 3 & 0x7) 
00954                                                     /* index at 24 */ < 8)) 
00955                                               goto MATCH_label_c819;  /*opt-block+*/
00956                                             else 
00957                                               goto MATCH_label_c820;  /*opt-block+*/
00958                                             
00959                                             break;
00960                                           case 3: 
00961                                             goto MATCH_label_c817; break;
00962                                           default: assert(0);
00963                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
00964                                               -- mod at 16 --*/ 
00965                                       break;
00966                                     default: assert(0);
00967                                   } /* (MATCH_w_8_16 >> 3 & 0x7) 
00968                                         -- reg_opcode at 16 --*/ 
00969                                 
00970                               } /*opt-block*/
00971                               break;
00972                             case 1: 
00973                               if ((MATCH_w_8_8 >> 3 & 0x1) 
00974                                       /* page at 8 */ == 1) { 
00975                                 nextPC = 2 + MATCH_p; 
00976                                 
00977 #line 366 "frontend/machine/pentium/decoder.m"
00978                                 
00979 
00980                                         stmts = instantiate(pc,  "WBINVD");
00981 
00982                                 
00983 
00984                                 
00985                                 
00986                                 
00987                               } /*opt-block*//*opt-block+*/
00988                               else { 
00989                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
00990                                 
00991                                   switch((MATCH_w_8_16 >> 3 & 0x7) 
00992                                         /* reg_opcode at 16 */) {
00993                                     case 0: 
00994                                       
00995                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
00996                                               /* mod at 16 */) {
00997                                           case 0: 
00998                                             
00999                                               switch((MATCH_w_8_16 & 0x7) 
01000                                                     /* r_m at 16 */) {
01001                                                 case 0: case 1: case 2: 
01002                                                 case 3: case 6: case 7: 
01003                                                   { 
01004                                                     unsigned Mem = 
01005                                                       2 + 
01006                                                       addressToPC(MATCH_p);
01007                                                     nextPC = 3 + MATCH_p; 
01008                                                     
01009 #line 459 "frontend/machine/pentium/decoder.m"
01010                                                     
01011 
01012                                                             stmts = instantiate(pc,  "SGDT", DIS_MEM);
01013 
01014                                                     
01015 
01016                                                         // Sets are now in the high level instructions
01017 
01018                                                     
01019                                                     
01020                                                     
01021                                                   }
01022                                                   
01023                                                   break;
01024                                                 case 4: 
01025                                                   MATCH_w_8_24 = 
01026                                                     getByte(3 + MATCH_p); 
01027                                                   if ((MATCH_w_8_24 & 0x7) 
01028                                                           /* base at 24 */ == 5 && 
01029                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01030                                                           /* index at 24 */ && 
01031                                                     (MATCH_w_8_24 >> 3 & 0x7) 
01032                                                           /* index at 24 */ < 8)) 
01033                                                     goto MATCH_label_c822;  /*opt-block+*/
01034                                                   else 
01035                                                     goto MATCH_label_c821;  /*opt-block+*/
01036                                                   
01037                                                   break;
01038                                                 case 5: 
01039                                                   goto MATCH_label_c823; 
01040                                                   
01041                                                   break;
01042                                                 default: assert(0);
01043                                               } /* (MATCH_w_8_16 & 0x7) 
01044                                                     -- r_m at 16 --*/ 
01045                                             break;
01046                                           case 1: 
01047                                             MATCH_w_8_24 = 
01048                                               getByte(3 + MATCH_p); 
01049                                             if ((MATCH_w_8_16 & 0x7) 
01050                                                     /* r_m at 16 */ == 4 && 
01051                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01052                                                     /* index at 24 */ && 
01053                                               (MATCH_w_8_24 >> 3 & 0x7) 
01054                                                     /* index at 24 */ < 8)) { 
01055                                               unsigned Mem = 
01056                                                 2 + addressToPC(MATCH_p);
01057                                               nextPC = 5 + MATCH_p; 
01058                                               
01059 #line 459 "frontend/machine/pentium/decoder.m"
01060                                               
01061 
01062                                                     stmts = instantiate(pc,  "SGDT", DIS_MEM);
01063 
01064                                               
01065 
01066                                                 // Sets are now in the high level instructions
01067 
01068                                               
01069                                               
01070                                               
01071                                             } /*opt-block*//*opt-block+*/
01072                                             else 
01073                                               goto MATCH_label_c821;  /*opt-block+*/
01074                                             
01075                                             break;
01076                                           case 2: 
01077                                             MATCH_w_8_24 = 
01078                                               getByte(3 + MATCH_p); 
01079                                             if ((MATCH_w_8_16 & 0x7) 
01080                                                     /* r_m at 16 */ == 4 && 
01081                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01082                                                     /* index at 24 */ && 
01083                                               (MATCH_w_8_24 >> 3 & 0x7) 
01084                                                     /* index at 24 */ < 8)) 
01085                                               goto MATCH_label_c822;  /*opt-block+*/
01086                                             else 
01087                                               goto MATCH_label_c823;  /*opt-block+*/
01088                                             
01089                                             break;
01090                                           case 3: 
01091                                             goto MATCH_label_c64; break;
01092                                           default: assert(0);
01093                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
01094                                               -- mod at 16 --*/ 
01095                                       break;
01096                                     case 1: 
01097                                       
01098                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
01099                                               /* mod at 16 */) {
01100                                           case 0: 
01101                                             
01102                                               switch((MATCH_w_8_16 & 0x7) 
01103                                                     /* r_m at 16 */) {
01104                                                 case 0: case 1: case 2: 
01105                                                 case 3: case 6: case 7: 
01106                                                   { 
01107                                                     unsigned Mem = 
01108                                                       2 + 
01109                                                       addressToPC(MATCH_p);
01110                                                     nextPC = 3 + MATCH_p; 
01111                                                     
01112 #line 456 "frontend/machine/pentium/decoder.m"
01113                                                     
01114 
01115                                                             stmts = instantiate(pc,  "SIDT", DIS_MEM);
01116 
01117                                                     
01118 
01119                                                     
01120                                                     
01121                                                     
01122                                                   }
01123                                                   
01124                                                   break;
01125                                                 case 4: 
01126                                                   MATCH_w_8_24 = 
01127                                                     getByte(3 + MATCH_p); 
01128                                                   if ((MATCH_w_8_24 & 0x7) 
01129                                                           /* base at 24 */ == 5 && 
01130                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01131                                                           /* index at 24 */ && 
01132                                                     (MATCH_w_8_24 >> 3 & 0x7) 
01133                                                           /* index at 24 */ < 8)) 
01134                                                     goto MATCH_label_c825;  /*opt-block+*/
01135                                                   else 
01136                                                     goto MATCH_label_c824;  /*opt-block+*/
01137                                                   
01138                                                   break;
01139                                                 case 5: 
01140                                                   goto MATCH_label_c826; 
01141                                                   
01142                                                   break;
01143                                                 default: assert(0);
01144                                               } /* (MATCH_w_8_16 & 0x7) 
01145                                                     -- r_m at 16 --*/ 
01146                                             break;
01147                                           case 1: 
01148                                             MATCH_w_8_24 = 
01149                                               getByte(3 + MATCH_p); 
01150                                             if ((MATCH_w_8_16 & 0x7) 
01151                                                     /* r_m at 16 */ == 4 && 
01152                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01153                                                     /* index at 24 */ && 
01154                                               (MATCH_w_8_24 >> 3 & 0x7) 
01155                                                     /* index at 24 */ < 8)) { 
01156                                               unsigned Mem = 
01157                                                 2 + addressToPC(MATCH_p);
01158                                               nextPC = 5 + MATCH_p; 
01159                                               
01160 #line 456 "frontend/machine/pentium/decoder.m"
01161                                               
01162 
01163                                                     stmts = instantiate(pc,  "SIDT", DIS_MEM);
01164 
01165                                               
01166 
01167                                               
01168                                               
01169                                               
01170                                             } /*opt-block*//*opt-block+*/
01171                                             else 
01172                                               goto MATCH_label_c824;  /*opt-block+*/
01173                                             
01174                                             break;
01175                                           case 2: 
01176                                             MATCH_w_8_24 = 
01177                                               getByte(3 + MATCH_p); 
01178                                             if ((MATCH_w_8_16 & 0x7) 
01179                                                     /* r_m at 16 */ == 4 && 
01180                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01181                                                     /* index at 24 */ && 
01182                                               (MATCH_w_8_24 >> 3 & 0x7) 
01183                                                     /* index at 24 */ < 8)) 
01184                                               goto MATCH_label_c825;  /*opt-block+*/
01185                                             else 
01186                                               goto MATCH_label_c826;  /*opt-block+*/
01187                                             
01188                                             break;
01189                                           case 3: 
01190                                             goto MATCH_label_c64; break;
01191                                           default: assert(0);
01192                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
01193                                               -- mod at 16 --*/ 
01194                                       break;
01195                                     case 2: case 3: case 5: case 6: 
01196                                       goto MATCH_label_c64; break;
01197                                     case 4: 
01198                                       
01199                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
01200                                               /* mod at 16 */) {
01201                                           case 0: 
01202                                             
01203                                               switch((MATCH_w_8_16 & 0x7) 
01204                                                     /* r_m at 16 */) {
01205                                                 case 0: case 1: case 2: 
01206                                                 case 3: case 6: case 7: 
01207                                                   goto MATCH_label_c827; 
01208                                                   
01209                                                   break;
01210                                                 case 4: 
01211                                                   MATCH_w_8_24 = 
01212                                                     getByte(3 + MATCH_p); 
01213                                                   if ((MATCH_w_8_24 & 0x7) 
01214                                                           /* base at 24 */ == 5 && 
01215                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01216                                                           /* index at 24 */ && 
01217                                                     (MATCH_w_8_24 >> 3 & 0x7) 
01218                                                           /* index at 24 */ < 8)) 
01219                                                     goto MATCH_label_c829;  /*opt-block+*/
01220                                                   else 
01221                                                     goto MATCH_label_c828;  /*opt-block+*/
01222                                                   
01223                                                   break;
01224                                                 case 5: 
01225                                                   goto MATCH_label_c830; 
01226                                                   
01227                                                   break;
01228                                                 default: assert(0);
01229                                               } /* (MATCH_w_8_16 & 0x7) 
01230                                                     -- r_m at 16 --*/ 
01231                                             break;
01232                                           case 1: 
01233                                             MATCH_w_8_24 = 
01234                                               getByte(3 + MATCH_p); 
01235                                             if ((MATCH_w_8_16 & 0x7) 
01236                                                     /* r_m at 16 */ == 4 && 
01237                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01238                                                     /* index at 24 */ && 
01239                                               (MATCH_w_8_24 >> 3 & 0x7) 
01240                                                     /* index at 24 */ < 8)) { 
01241                                               unsigned Eaddr = 
01242                                                 2 + addressToPC(MATCH_p);
01243                                               nextPC = 5 + MATCH_p; 
01244                                               
01245 #line 426 "frontend/machine/pentium/decoder.m"
01246                                               
01247 
01248                                                     stmts = instantiate(pc,  "SMSW", DIS_EADDR32);
01249 
01250                                               
01251 
01252                                               
01253                                               
01254                                               
01255                                             } /*opt-block*//*opt-block+*/
01256                                             else 
01257                                               goto MATCH_label_c828;  /*opt-block+*/
01258                                             
01259                                             break;
01260                                           case 2: 
01261                                             MATCH_w_8_24 = 
01262                                               getByte(3 + MATCH_p); 
01263                                             if ((MATCH_w_8_16 & 0x7) 
01264                                                     /* r_m at 16 */ == 4 && 
01265                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01266                                                     /* index at 24 */ && 
01267                                               (MATCH_w_8_24 >> 3 & 0x7) 
01268                                                     /* index at 24 */ < 8)) 
01269                                               goto MATCH_label_c829;  /*opt-block+*/
01270                                             else 
01271                                               goto MATCH_label_c830;  /*opt-block+*/
01272                                             
01273                                             break;
01274                                           case 3: 
01275                                             goto MATCH_label_c827; break;
01276                                           default: assert(0);
01277                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
01278                                               -- mod at 16 --*/ 
01279                                       break;
01280                                     case 7: 
01281                                       
01282                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
01283                                               /* mod at 16 */) {
01284                                           case 0: 
01285                                             
01286                                               switch((MATCH_w_8_16 & 0x7) 
01287                                                     /* r_m at 16 */) {
01288                                                 case 0: case 1: case 2: 
01289                                                 case 3: case 6: case 7: 
01290                                                   { 
01291                                                     unsigned Mem = 
01292                                                       2 + 
01293                                                       addressToPC(MATCH_p);
01294                                                     nextPC = 3 + MATCH_p; 
01295                                                     
01296 #line 1095 "frontend/machine/pentium/decoder.m"
01297                                                     
01298 
01299                                                             stmts = instantiate(pc,  "INVLPG", DIS_MEM);
01300 
01301                                                     
01302 
01303                                                     
01304                                                     
01305                                                     
01306                                                   }
01307                                                   
01308                                                   break;
01309                                                 case 4: 
01310                                                   MATCH_w_8_24 = 
01311                                                     getByte(3 + MATCH_p); 
01312                                                   if ((MATCH_w_8_24 & 0x7) 
01313                                                           /* base at 24 */ == 5 && 
01314                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01315                                                           /* index at 24 */ && 
01316                                                     (MATCH_w_8_24 >> 3 & 0x7) 
01317                                                           /* index at 24 */ < 8)) 
01318                                                     goto MATCH_label_c832;  /*opt-block+*/
01319                                                   else 
01320                                                     goto MATCH_label_c831;  /*opt-block+*/
01321                                                   
01322                                                   break;
01323                                                 case 5: 
01324                                                   goto MATCH_label_c833; 
01325                                                   
01326                                                   break;
01327                                                 default: assert(0);
01328                                               } /* (MATCH_w_8_16 & 0x7) 
01329                                                     -- r_m at 16 --*/ 
01330                                             break;
01331                                           case 1: 
01332                                             MATCH_w_8_24 = 
01333                                               getByte(3 + MATCH_p); 
01334                                             if ((MATCH_w_8_16 & 0x7) 
01335                                                     /* r_m at 16 */ == 4 && 
01336                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01337                                                     /* index at 24 */ && 
01338                                               (MATCH_w_8_24 >> 3 & 0x7) 
01339                                                     /* index at 24 */ < 8)) { 
01340                                               unsigned Mem = 
01341                                                 2 + addressToPC(MATCH_p);
01342                                               nextPC = 5 + MATCH_p; 
01343                                               
01344 #line 1095 "frontend/machine/pentium/decoder.m"
01345                                               
01346 
01347                                                     stmts = instantiate(pc,  "INVLPG", DIS_MEM);
01348 
01349                                               
01350 
01351                                               
01352                                               
01353                                               
01354                                             } /*opt-block*//*opt-block+*/
01355                                             else 
01356                                               goto MATCH_label_c831;  /*opt-block+*/
01357                                             
01358                                             break;
01359                                           case 2: 
01360                                             MATCH_w_8_24 = 
01361                                               getByte(3 + MATCH_p); 
01362                                             if ((MATCH_w_8_16 & 0x7) 
01363                                                     /* r_m at 16 */ == 4 && 
01364                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01365                                                     /* index at 24 */ && 
01366                                               (MATCH_w_8_24 >> 3 & 0x7) 
01367                                                     /* index at 24 */ < 8)) 
01368                                               goto MATCH_label_c832;  /*opt-block+*/
01369                                             else 
01370                                               goto MATCH_label_c833;  /*opt-block+*/
01371                                             
01372                                             break;
01373                                           case 3: 
01374                                             goto MATCH_label_c64; break;
01375                                           default: assert(0);
01376                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
01377                                               -- mod at 16 --*/ 
01378                                       break;
01379                                     default: assert(0);
01380                                   } /* (MATCH_w_8_16 >> 3 & 0x7) 
01381                                         -- reg_opcode at 16 --*/ 
01382                                 
01383                               } /*opt-block*/
01384                               break;
01385                             case 2: 
01386                               if ((MATCH_w_8_8 >> 3 & 0x1) 
01387                                       /* page at 8 */ == 1) 
01388                                 goto MATCH_label_c64;  /*opt-block+*/
01389                               else { 
01390                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
01391                                 
01392                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
01393                                         /* mod at 16 */) {
01394                                     case 0: 
01395                                       
01396                                         switch((MATCH_w_8_16 & 0x7) 
01397                                               /* r_m at 16 */) {
01398                                           case 0: case 1: case 2: case 3: 
01399                                           case 6: case 7: 
01400                                             goto MATCH_label_c834; break;
01401                                           case 4: 
01402                                             MATCH_w_8_24 = 
01403                                               getByte(3 + MATCH_p); 
01404                                             if ((MATCH_w_8_24 & 0x7) 
01405                                                     /* base at 24 */ == 5 && 
01406                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01407                                                     /* index at 24 */ && 
01408                                               (MATCH_w_8_24 >> 3 & 0x7) 
01409                                                     /* index at 24 */ < 8)) 
01410                                               goto MATCH_label_c836;  /*opt-block+*/
01411                                             else 
01412                                               goto MATCH_label_c835;  /*opt-block+*/
01413                                             
01414                                             break;
01415                                           case 5: 
01416                                             goto MATCH_label_c837; break;
01417                                           default: assert(0);
01418                                         } /* (MATCH_w_8_16 & 0x7) 
01419                                               -- r_m at 16 --*/ 
01420                                       break;
01421                                     case 1: 
01422                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
01423                                       if ((MATCH_w_8_16 & 0x7) 
01424                                               /* r_m at 16 */ == 4 && 
01425                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01426                                               /* index at 24 */ && 
01427                                         (MATCH_w_8_24 >> 3 & 0x7) 
01428                                               /* index at 24 */ < 8)) { 
01429                                         unsigned Eaddr = 
01430                                           2 + addressToPC(MATCH_p);
01431                                         unsigned reg = 
01432                                           (MATCH_w_8_16 >> 3 & 0x7) 
01433                                                 /* reg_opcode at 16 */;
01434                                         nextPC = 5 + MATCH_p; 
01435                                         
01436 #line 1082 "frontend/machine/pentium/decoder.m"
01437                                         
01438 
01439                                                 stmts = instantiate(pc,  "LAR.od", DIS_REG32, DIS_EADDR32);
01440 
01441                                         
01442 
01443                                         
01444                                         
01445                                         
01446                                       } /*opt-block*//*opt-block+*/
01447                                       else 
01448                                         goto MATCH_label_c835;  /*opt-block+*/
01449                                       
01450                                       break;
01451                                     case 2: 
01452                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
01453                                       if ((MATCH_w_8_16 & 0x7) 
01454                                               /* r_m at 16 */ == 4 && 
01455                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01456                                               /* index at 24 */ && 
01457                                         (MATCH_w_8_24 >> 3 & 0x7) 
01458                                               /* index at 24 */ < 8)) 
01459                                         goto MATCH_label_c836;  /*opt-block+*/
01460                                       else 
01461                                         goto MATCH_label_c837;  /*opt-block+*/
01462                                       
01463                                       break;
01464                                     case 3: 
01465                                       goto MATCH_label_c834; break;
01466                                     default: assert(0);
01467                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
01468                                         -- mod at 16 --*/ 
01469                                 
01470                               } /*opt-block*/
01471                               break;
01472                             case 3: 
01473                               if ((MATCH_w_8_8 >> 3 & 0x1) 
01474                                       /* page at 8 */ == 1) 
01475                                 goto MATCH_label_c64;  /*opt-block+*/
01476                               else { 
01477                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
01478                                 
01479                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
01480                                         /* mod at 16 */) {
01481                                     case 0: 
01482                                       
01483                                         switch((MATCH_w_8_16 & 0x7) 
01484                                               /* r_m at 16 */) {
01485                                           case 0: case 1: case 2: case 3: 
01486                                           case 6: case 7: 
01487                                             goto MATCH_label_c838; break;
01488                                           case 4: 
01489                                             MATCH_w_8_24 = 
01490                                               getByte(3 + MATCH_p); 
01491                                             if ((MATCH_w_8_24 & 0x7) 
01492                                                     /* base at 24 */ == 5 && 
01493                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01494                                                     /* index at 24 */ && 
01495                                               (MATCH_w_8_24 >> 3 & 0x7) 
01496                                                     /* index at 24 */ < 8)) 
01497                                               goto MATCH_label_c840;  /*opt-block+*/
01498                                             else 
01499                                               goto MATCH_label_c839;  /*opt-block+*/
01500                                             
01501                                             break;
01502                                           case 5: 
01503                                             goto MATCH_label_c841; break;
01504                                           default: assert(0);
01505                                         } /* (MATCH_w_8_16 & 0x7) 
01506                                               -- r_m at 16 --*/ 
01507                                       break;
01508                                     case 1: 
01509                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
01510                                       if ((MATCH_w_8_16 & 0x7) 
01511                                               /* r_m at 16 */ == 4 && 
01512                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01513                                               /* index at 24 */ && 
01514                                         (MATCH_w_8_24 >> 3 & 0x7) 
01515                                               /* index at 24 */ < 8)) { 
01516                                         unsigned Eaddr = 
01517                                           2 + addressToPC(MATCH_p);
01518                                         unsigned reg = 
01519                                           (MATCH_w_8_16 >> 3 & 0x7) 
01520                                                 /* reg_opcode at 16 */;
01521                                         nextPC = 5 + MATCH_p; 
01522                                         
01523 #line 1046 "frontend/machine/pentium/decoder.m"
01524                                         
01525 
01526                                                 stmts = instantiate(pc,  "LSLod", DIS_REG32, DIS_EADDR32);
01527 
01528                                         
01529 
01530                                         
01531                                         
01532                                         
01533                                       } /*opt-block*//*opt-block+*/
01534                                       else 
01535                                         goto MATCH_label_c839;  /*opt-block+*/
01536                                       
01537                                       break;
01538                                     case 2: 
01539                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
01540                                       if ((MATCH_w_8_16 & 0x7) 
01541                                               /* r_m at 16 */ == 4 && 
01542                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01543                                               /* index at 24 */ && 
01544                                         (MATCH_w_8_24 >> 3 & 0x7) 
01545                                               /* index at 24 */ < 8)) 
01546                                         goto MATCH_label_c840;  /*opt-block+*/
01547                                       else 
01548                                         goto MATCH_label_c841;  /*opt-block+*/
01549                                       
01550                                       break;
01551                                     case 3: 
01552                                       goto MATCH_label_c838; break;
01553                                     default: assert(0);
01554                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
01555                                         -- mod at 16 --*/ 
01556                                 
01557                               } /*opt-block*/
01558                               break;
01559                             case 4: case 5: case 7: 
01560                               goto MATCH_label_c64; break;
01561                             case 6: 
01562                               if ((MATCH_w_8_8 >> 3 & 0x1) 
01563                                       /* page at 8 */ == 0) { 
01564                                 nextPC = 2 + MATCH_p; 
01565                                 
01566 #line 1259 "frontend/machine/pentium/decoder.m"
01567                                 
01568 
01569                                         stmts = instantiate(pc,  "CLTS");
01570 
01571                                 
01572 
01573                                 
01574                                 
01575                                 
01576                               } /*opt-block*//*opt-block+*/
01577                               else 
01578                                 goto MATCH_label_c64;  /*opt-block+*/
01579                               
01580                               break;
01581                             default: assert(0);
01582                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
01583                         break;
01584                       case 1: case 2: case 4: case 5: case 6: case 7: 
01585                       case 13: case 14: case 15: 
01586                         goto MATCH_label_c64; break;
01587                       case 3: 
01588                         
01589                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
01590                             case 0: 
01591                               if ((MATCH_w_8_8 >> 3 & 0x1) 
01592                                       /* page at 8 */ == 0) { 
01593                                 nextPC = 2 + MATCH_p; 
01594                                 
01595 #line 363 "frontend/machine/pentium/decoder.m"
01596                                 
01597 
01598                                         stmts = instantiate(pc,  "WRMSR");
01599 
01600                                 
01601 
01602                                 
01603                                 
01604                                 
01605                               } /*opt-block*//*opt-block+*/
01606                               else 
01607                                 goto MATCH_label_c64;  /*opt-block+*/
01608                               
01609                               break;
01610                             case 1: case 3: case 4: case 5: case 6: case 7: 
01611                               goto MATCH_label_c64; break;
01612                             case 2: 
01613                               if ((MATCH_w_8_8 >> 3 & 0x1) 
01614                                       /* page at 8 */ == 0) { 
01615                                 nextPC = 2 + MATCH_p; 
01616                                 
01617 #line 596 "frontend/machine/pentium/decoder.m"
01618                                 
01619 
01620                                         stmts = instantiate(pc,  "RDMSR");
01621 
01622                                 
01623 
01624                                 
01625                                 
01626                                 
01627                               } /*opt-block*//*opt-block+*/
01628                               else 
01629                                 goto MATCH_label_c64;  /*opt-block+*/
01630                               
01631                               break;
01632                             default: assert(0);
01633                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
01634                         break;
01635                       case 8: 
01636                         if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) 
01637                           
01638                             switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
01639                               case 0: 
01640                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
01641                                 { 
01642                                   unsigned relocd = 
01643                                     6 + MATCH_w_32_16 /* i32 at 16 */ + 
01644                                     addressToPC(MATCH_p);
01645                                   nextPC = 6 + MATCH_p; 
01646                                   
01647 #line 246 "frontend/machine/pentium/decoder.m"
01648                                   
01649 
01650                                         COND_JUMP("Jv.Sod", 6, relocd, BRANCH_JMI)
01651 
01652                                   
01653                                   
01654                                   
01655                                 }
01656                                 
01657                                 break;
01658                               case 1: 
01659                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
01660                                 { 
01661                                   unsigned relocd = 
01662                                     6 + MATCH_w_32_16 /* i32 at 16 */ + 
01663                                     addressToPC(MATCH_p);
01664                                   nextPC = 6 + MATCH_p; 
01665                                   
01666 #line 244 "frontend/machine/pentium/decoder.m"
01667                                   
01668 
01669                                         COND_JUMP("Jv.NSod", 6, relocd, BRANCH_JPOS)
01670 
01671                                   
01672                                   
01673                                   
01674                                 }
01675                                 
01676                                 break;
01677                               case 2: 
01678                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
01679                                 { 
01680                                   unsigned relocd = 
01681                                     6 + MATCH_w_32_16 /* i32 at 16 */ + 
01682                                     addressToPC(MATCH_p);
01683                                   nextPC = 6 + MATCH_p; 
01684                                   
01685 #line 242 "frontend/machine/pentium/decoder.m"
01686                                   
01687 
01688                                         COND_JUMP("Jv.Pod", 6, relocd, BRANCH_JPAR)
01689 
01690                                   
01691                                   
01692                                   
01693                                 }
01694                                 
01695                                 break;
01696                               case 3: 
01697                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
01698                                 { 
01699                                   unsigned relocd = 
01700                                     6 + MATCH_w_32_16 /* i32 at 16 */ + 
01701                                     addressToPC(MATCH_p);
01702                                   nextPC = 6 + MATCH_p; 
01703                                   
01704 #line 240 "frontend/machine/pentium/decoder.m"
01705                                   
01706 
01707                                         COND_JUMP("Jv.NPod", 6, relocd, (BRANCH_TYPE)0)
01708 
01709                                   
01710                                   
01711                                   
01712                                 }
01713                                 
01714                                 break;
01715                               case 4: 
01716                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
01717                                 { 
01718                                   unsigned relocd = 
01719                                     6 + MATCH_w_32_16 /* i32 at 16 */ + 
01720                                     addressToPC(MATCH_p);
01721                                   nextPC = 6 + MATCH_p; 
01722                                   
01723 #line 238 "frontend/machine/pentium/decoder.m"
01724                                   
01725 
01726                                         COND_JUMP("Jv.Lod", 6, relocd, BRANCH_JSL)
01727 
01728                                   
01729                                   
01730                                   
01731                                 }
01732                                 
01733                                 break;
01734                               case 5: 
01735                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
01736                                 { 
01737                                   unsigned relocd = 
01738                                     6 + MATCH_w_32_16 /* i32 at 16 */ + 
01739                                     addressToPC(MATCH_p);
01740                                   nextPC = 6 + MATCH_p; 
01741                                   
01742 #line 236 "frontend/machine/pentium/decoder.m"
01743                                   
01744 
01745                                         COND_JUMP("Jv.NLod", 6, relocd, BRANCH_JSGE)
01746 
01747                                   
01748                                   
01749                                   
01750                                 }
01751                                 
01752                                 break;
01753                               case 6: 
01754                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
01755                                 { 
01756                                   unsigned relocd = 
01757                                     6 + MATCH_w_32_16 /* i32 at 16 */ + 
01758                                     addressToPC(MATCH_p);
01759                                   nextPC = 6 + MATCH_p; 
01760                                   
01761 #line 234 "frontend/machine/pentium/decoder.m"
01762                                   
01763 
01764                                         COND_JUMP("Jv.LEod", 6, relocd, BRANCH_JSLE)
01765 
01766                                   
01767                                   
01768                                   
01769                                 }
01770                                 
01771                                 break;
01772                               case 7: 
01773                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
01774                                 { 
01775                                   unsigned relocd = 
01776                                     6 + MATCH_w_32_16 /* i32 at 16 */ + 
01777                                     addressToPC(MATCH_p);
01778                                   nextPC = 6 + MATCH_p; 
01779                                   
01780 #line 232 "frontend/machine/pentium/decoder.m"
01781                                   
01782 
01783                                         COND_JUMP("Jv.NLEod", 6, relocd, BRANCH_JSG)
01784 
01785                                   
01786                                   
01787                                   
01788                                 }
01789                                 
01790                                 break;
01791                               default: assert(0);
01792                             } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/  
01793                         else 
01794                           
01795                             switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
01796                               case 0: 
01797                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
01798                                 { 
01799                                   unsigned relocd = 
01800                                     6 + MATCH_w_32_16 /* i32 at 16 */ + 
01801                                     addressToPC(MATCH_p);
01802                                   nextPC = 6 + MATCH_p; 
01803                                   
01804 #line 263 "frontend/machine/pentium/decoder.m"
01805                                   
01806 
01807                                         COND_JUMP("Jv.Ood", 6, relocd, (BRANCH_TYPE)0)
01808 
01809                                   
01810 
01811                                   
01812                                   
01813                                   
01814                                 }
01815                                 
01816                                 break;
01817                               case 1: 
01818                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
01819                                 { 
01820                                   unsigned relocd = 
01821                                     6 + MATCH_w_32_16 /* i32 at 16 */ + 
01822                                     addressToPC(MATCH_p);
01823                                   nextPC = 6 + MATCH_p; 
01824                                   
01825 #line 260 "frontend/machine/pentium/decoder.m"
01826                                   
01827 
01828                                         COND_JUMP("Jv.NOod", 6, relocd, (BRANCH_TYPE)0)
01829 
01830                                   
01831                                   
01832                                   
01833                                 }
01834                                 
01835                                 break;
01836                               case 2: 
01837                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
01838                                 { 
01839                                   unsigned relocd = 
01840                                     6 + MATCH_w_32_16 /* i32 at 16 */ + 
01841                                     addressToPC(MATCH_p);
01842                                   nextPC = 6 + MATCH_p; 
01843                                   
01844 #line 258 "frontend/machine/pentium/decoder.m"
01845                                   
01846 
01847                                         COND_JUMP("Jv.Bod", 6, relocd, BRANCH_JUL)
01848 
01849                                   
01850                                   
01851                                   
01852                                 }
01853                                 
01854                                 break;
01855                               case 3: 
01856                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
01857                                 { 
01858                                   unsigned relocd = 
01859                                     6 + MATCH_w_32_16 /* i32 at 16 */ + 
01860                                     addressToPC(MATCH_p);
01861                                   nextPC = 6 + MATCH_p; 
01862                                   
01863 #line 256 "frontend/machine/pentium/decoder.m"
01864                                   
01865 
01866                                         COND_JUMP("Jv.NBod", 6, relocd, BRANCH_JUGE)
01867 
01868                                   
01869                                   
01870                                   
01871                                 }
01872                                 
01873                                 break;
01874                               case 4: 
01875                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
01876                                 { 
01877                                   unsigned relocd = 
01878                                     6 + MATCH_w_32_16 /* i32 at 16 */ + 
01879                                     addressToPC(MATCH_p);
01880                                   nextPC = 6 + MATCH_p; 
01881                                   
01882 #line 254 "frontend/machine/pentium/decoder.m"
01883                                   
01884 
01885                                         COND_JUMP("Jv.Zod", 6, relocd, BRANCH_JE)
01886 
01887                                   
01888                                   
01889                                   
01890                                 }
01891                                 
01892                                 break;
01893                               case 5: 
01894                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
01895                                 { 
01896                                   unsigned relocd = 
01897                                     6 + MATCH_w_32_16 /* i32 at 16 */ + 
01898                                     addressToPC(MATCH_p);
01899                                   nextPC = 6 + MATCH_p; 
01900                                   
01901 #line 252 "frontend/machine/pentium/decoder.m"
01902                                   
01903 
01904                                         COND_JUMP("Jv.NZod", 6, relocd, BRANCH_JNE)
01905 
01906                                   
01907                                   
01908                                   
01909                                 }
01910                                 
01911                                 break;
01912                               case 6: 
01913                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
01914                                 { 
01915                                   unsigned relocd = 
01916                                     6 + MATCH_w_32_16 /* i32 at 16 */ + 
01917                                     addressToPC(MATCH_p);
01918                                   nextPC = 6 + MATCH_p; 
01919                                   
01920 #line 250 "frontend/machine/pentium/decoder.m"
01921                                   
01922 
01923                                         COND_JUMP("Jv.BEod", 6, relocd, BRANCH_JULE)
01924 
01925                                   
01926                                   
01927                                   
01928                                 }
01929                                 
01930                                 break;
01931                               case 7: 
01932                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
01933                                 { 
01934                                   unsigned relocd = 
01935                                     6 + MATCH_w_32_16 /* i32 at 16 */ + 
01936                                     addressToPC(MATCH_p);
01937                                   nextPC = 6 + MATCH_p; 
01938                                   
01939 #line 248 "frontend/machine/pentium/decoder.m"
01940                                   
01941 
01942                                         COND_JUMP("Jv.NBEod", 6, relocd, BRANCH_JUG)
01943 
01944                                   
01945                                   
01946                                   
01947                                 }
01948                                 
01949                                 break;
01950                               default: assert(0);
01951                             } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/  
01952                         break;
01953                       case 9: 
01954                         if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) 
01955                           
01956                             switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
01957                               case 0: 
01958                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
01959                                 
01960                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
01961                                         /* mod at 16 */) {
01962                                     case 0: 
01963                                       
01964                                         switch((MATCH_w_8_16 & 0x7) 
01965                                               /* r_m at 16 */) {
01966                                           case 0: case 1: case 2: case 3: 
01967                                           case 6: case 7: 
01968                                             MATCH_name = "SETb.S"; 
01969                                             goto MATCH_label_c866; 
01970                                             
01971                                             break;
01972                                           case 4: 
01973                                             MATCH_w_8_24 = 
01974                                               getByte(3 + MATCH_p); 
01975                                             if ((MATCH_w_8_24 & 0x7) 
01976                                                     /* base at 24 */ == 5 && 
01977                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01978                                                     /* index at 24 */ && 
01979                                               (MATCH_w_8_24 >> 3 & 0x7) 
01980                                                     /* index at 24 */ < 8)) { 
01981                                               MATCH_name = "SETb.S"; 
01982                                               goto MATCH_label_c868; 
01983                                               
01984                                             } /*opt-block*/
01985                                             else { 
01986                                               MATCH_name = "SETb.S"; 
01987                                               goto MATCH_label_c867; 
01988                                               
01989                                             } /*opt-block*/
01990                                             
01991                                             break;
01992                                           case 5: 
01993                                             MATCH_name = "SETb.S"; 
01994                                             goto MATCH_label_c869; 
01995                                             
01996                                             break;
01997                                           default: assert(0);
01998                                         } /* (MATCH_w_8_16 & 0x7) 
01999                                               -- r_m at 16 --*/ 
02000                                       break;
02001                                     case 1: 
02002                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02003                                       if ((MATCH_w_8_16 & 0x7) 
02004                                               /* r_m at 16 */ == 4 && 
02005                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02006                                               /* index at 24 */ && 
02007                                         (MATCH_w_8_24 >> 3 & 0x7) 
02008                                               /* index at 24 */ < 8)) { 
02009                                         MATCH_name = "SETb.S"; 
02010                                         { 
02011                                           char *name = MATCH_name;
02012                                           unsigned Eaddr = 
02013                                             2 + addressToPC(MATCH_p);
02014                                           nextPC = 5 + MATCH_p; 
02015                                           
02016 #line 287 "frontend/machine/pentium/decoder.m"
02017                                           
02018 
02019                                                 stmts = instantiate(pc, name, DIS_EADDR8);
02020 
02021                                                 SETS(name, DIS_EADDR8, BRANCH_JMI)
02022 
02023                                           
02024                                           
02025                                           
02026                                         }
02027                                         
02028                                       } /*opt-block*/
02029                                       else { 
02030                                         MATCH_name = "SETb.S"; 
02031                                         goto MATCH_label_c867; 
02032                                         
02033                                       } /*opt-block*/
02034                                       
02035                                       break;
02036                                     case 2: 
02037                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02038                                       if ((MATCH_w_8_16 & 0x7) 
02039                                               /* r_m at 16 */ == 4 && 
02040                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02041                                               /* index at 24 */ && 
02042                                         (MATCH_w_8_24 >> 3 & 0x7) 
02043                                               /* index at 24 */ < 8)) { 
02044                                         MATCH_name = "SETb.S"; 
02045                                         goto MATCH_label_c868; 
02046                                         
02047                                       } /*opt-block*/
02048                                       else { 
02049                                         MATCH_name = "SETb.S"; 
02050                                         goto MATCH_label_c869; 
02051                                         
02052                                       } /*opt-block*/
02053                                       
02054                                       break;
02055                                     case 3: 
02056                                       MATCH_name = "SETb.S"; 
02057                                       goto MATCH_label_c866; 
02058                                       
02059                                       break;
02060                                     default: assert(0);
02061                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
02062                                         -- mod at 16 --*/ 
02063                                 
02064                                 break;
02065                               case 1: 
02066                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
02067                                 
02068                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
02069                                         /* mod at 16 */) {
02070                                     case 0: 
02071                                       
02072                                         switch((MATCH_w_8_16 & 0x7) 
02073                                               /* r_m at 16 */) {
02074                                           case 0: case 1: case 2: case 3: 
02075                                           case 6: case 7: 
02076                                             MATCH_name = "SETb.NS"; 
02077                                             goto MATCH_label_c870; 
02078                                             
02079                                             break;
02080                                           case 4: 
02081                                             MATCH_w_8_24 = 
02082                                               getByte(3 + MATCH_p); 
02083                                             if ((MATCH_w_8_24 & 0x7) 
02084                                                     /* base at 24 */ == 5 && 
02085                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02086                                                     /* index at 24 */ && 
02087                                               (MATCH_w_8_24 >> 3 & 0x7) 
02088                                                     /* index at 24 */ < 8)) { 
02089                                               MATCH_name = "SETb.NS"; 
02090                                               goto MATCH_label_c872; 
02091                                               
02092                                             } /*opt-block*/
02093                                             else { 
02094                                               MATCH_name = "SETb.NS"; 
02095                                               goto MATCH_label_c871; 
02096                                               
02097                                             } /*opt-block*/
02098                                             
02099                                             break;
02100                                           case 5: 
02101                                             MATCH_name = "SETb.NS"; 
02102                                             goto MATCH_label_c873; 
02103                                             
02104                                             break;
02105                                           default: assert(0);
02106                                         } /* (MATCH_w_8_16 & 0x7) 
02107                                               -- r_m at 16 --*/ 
02108                                       break;
02109                                     case 1: 
02110                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02111                                       if ((MATCH_w_8_16 & 0x7) 
02112                                               /* r_m at 16 */ == 4 && 
02113                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02114                                               /* index at 24 */ && 
02115                                         (MATCH_w_8_24 >> 3 & 0x7) 
02116                                               /* index at 24 */ < 8)) { 
02117                                         MATCH_name = "SETb.NS"; 
02118                                         { 
02119                                           char *name = MATCH_name;
02120                                           unsigned Eaddr = 
02121                                             2 + addressToPC(MATCH_p);
02122                                           nextPC = 5 + MATCH_p; 
02123                                           
02124 #line 284 "frontend/machine/pentium/decoder.m"
02125                                           
02126 
02127                                                 stmts = instantiate(pc, name, DIS_EADDR8);
02128 
02129                                                 SETS(name, DIS_EADDR8, BRANCH_JPOS)
02130 
02131                                           
02132                                           
02133                                           
02134                                         }
02135                                         
02136                                       } /*opt-block*/
02137                                       else { 
02138                                         MATCH_name = "SETb.NS"; 
02139                                         goto MATCH_label_c871; 
02140                                         
02141                                       } /*opt-block*/
02142                                       
02143                                       break;
02144                                     case 2: 
02145                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02146                                       if ((MATCH_w_8_16 & 0x7) 
02147                                               /* r_m at 16 */ == 4 && 
02148                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02149                                               /* index at 24 */ && 
02150                                         (MATCH_w_8_24 >> 3 & 0x7) 
02151                                               /* index at 24 */ < 8)) { 
02152                                         MATCH_name = "SETb.NS"; 
02153                                         goto MATCH_label_c872; 
02154                                         
02155                                       } /*opt-block*/
02156                                       else { 
02157                                         MATCH_name = "SETb.NS"; 
02158                                         goto MATCH_label_c873; 
02159                                         
02160                                       } /*opt-block*/
02161                                       
02162                                       break;
02163                                     case 3: 
02164                                       MATCH_name = "SETb.NS"; 
02165                                       goto MATCH_label_c870; 
02166                                       
02167                                       break;
02168                                     default: assert(0);
02169                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
02170                                         -- mod at 16 --*/ 
02171                                 
02172                                 break;
02173                               case 2: case 3: 
02174                                 goto MATCH_label_c64; break;
02175                               case 4: 
02176                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
02177                                 
02178                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
02179                                         /* mod at 16 */) {
02180                                     case 0: 
02181                                       
02182                                         switch((MATCH_w_8_16 & 0x7) 
02183                                               /* r_m at 16 */) {
02184                                           case 0: case 1: case 2: case 3: 
02185                                           case 6: case 7: 
02186                                             MATCH_name = "SETb.L"; 
02187                                             goto MATCH_label_c874; 
02188                                             
02189                                             break;
02190                                           case 4: 
02191                                             MATCH_w_8_24 = 
02192                                               getByte(3 + MATCH_p); 
02193                                             if ((MATCH_w_8_24 & 0x7) 
02194                                                     /* base at 24 */ == 5 && 
02195                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02196                                                     /* index at 24 */ && 
02197                                               (MATCH_w_8_24 >> 3 & 0x7) 
02198                                                     /* index at 24 */ < 8)) { 
02199                                               MATCH_name = "SETb.L"; 
02200                                               goto MATCH_label_c876; 
02201                                               
02202                                             } /*opt-block*/
02203                                             else { 
02204                                               MATCH_name = "SETb.L"; 
02205                                               goto MATCH_label_c875; 
02206                                               
02207                                             } /*opt-block*/
02208                                             
02209                                             break;
02210                                           case 5: 
02211                                             MATCH_name = "SETb.L"; 
02212                                             goto MATCH_label_c877; 
02213                                             
02214                                             break;
02215                                           default: assert(0);
02216                                         } /* (MATCH_w_8_16 & 0x7) 
02217                                               -- r_m at 16 --*/ 
02218                                       break;
02219                                     case 1: 
02220                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02221                                       if ((MATCH_w_8_16 & 0x7) 
02222                                               /* r_m at 16 */ == 4 && 
02223                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02224                                               /* index at 24 */ && 
02225                                         (MATCH_w_8_24 >> 3 & 0x7) 
02226                                               /* index at 24 */ < 8)) { 
02227                                         MATCH_name = "SETb.L"; 
02228                                         { 
02229                                           char *name = MATCH_name;
02230                                           unsigned Eaddr = 
02231                                             2 + addressToPC(MATCH_p);
02232                                           nextPC = 5 + MATCH_p; 
02233                                           
02234 #line 275 "frontend/machine/pentium/decoder.m"
02235                                           
02236 
02237                                                 stmts = instantiate(pc, name, DIS_EADDR8);
02238 
02239                                                 SETS(name, DIS_EADDR8, BRANCH_JSL)
02240 
02241                                             //| SETb.NP(Eaddr) [name] =>
02242 
02243                                             //  stmts = instantiate(pc, name, DIS_EADDR8);
02244 
02245                                             //  SETS(name, DIS_EADDR8, BRANCH_JSG)
02246 
02247                                             //| SETb.P(Eaddr) [name] =>
02248 
02249                                             //  stmts = instantiate(pc, name, DIS_EADDR8);
02250 
02251                                             //  SETS(name, DIS_EADDR8, BRANCH_JSG)
02252 
02253                                           
02254                                           
02255                                           
02256                                         }
02257                                         
02258                                       } /*opt-block*/
02259                                       else { 
02260                                         MATCH_name = "SETb.L"; 
02261                                         goto MATCH_label_c875; 
02262                                         
02263                                       } /*opt-block*/
02264                                       
02265                                       break;
02266                                     case 2: 
02267                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02268                                       if ((MATCH_w_8_16 & 0x7) 
02269                                               /* r_m at 16 */ == 4 && 
02270                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02271                                               /* index at 24 */ && 
02272                                         (MATCH_w_8_24 >> 3 & 0x7) 
02273                                               /* index at 24 */ < 8)) { 
02274                                         MATCH_name = "SETb.L"; 
02275                                         goto MATCH_label_c876; 
02276                                         
02277                                       } /*opt-block*/
02278                                       else { 
02279                                         MATCH_name = "SETb.L"; 
02280                                         goto MATCH_label_c877; 
02281                                         
02282                                       } /*opt-block*/
02283                                       
02284                                       break;
02285                                     case 3: 
02286                                       MATCH_name = "SETb.L"; 
02287                                       goto MATCH_label_c874; 
02288                                       
02289                                       break;
02290                                     default: assert(0);
02291                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
02292                                         -- mod at 16 --*/ 
02293                                 
02294                                 break;
02295                               case 5: 
02296                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
02297                                 
02298                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
02299                                         /* mod at 16 */) {
02300                                     case 0: 
02301                                       
02302                                         switch((MATCH_w_8_16 & 0x7) 
02303                                               /* r_m at 16 */) {
02304                                           case 0: case 1: case 2: case 3: 
02305                                           case 6: case 7: 
02306                                             MATCH_name = "SETb.NL"; 
02307                                             goto MATCH_label_c878; 
02308                                             
02309                                             break;
02310                                           case 4: 
02311                                             MATCH_w_8_24 = 
02312                                               getByte(3 + MATCH_p); 
02313                                             if ((MATCH_w_8_24 & 0x7) 
02314                                                     /* base at 24 */ == 5 && 
02315                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02316                                                     /* index at 24 */ && 
02317                                               (MATCH_w_8_24 >> 3 & 0x7) 
02318                                                     /* index at 24 */ < 8)) { 
02319                                               MATCH_name = "SETb.NL"; 
02320                                               goto MATCH_label_c880; 
02321                                               
02322                                             } /*opt-block*/
02323                                             else { 
02324                                               MATCH_name = "SETb.NL"; 
02325                                               goto MATCH_label_c879; 
02326                                               
02327                                             } /*opt-block*/
02328                                             
02329                                             break;
02330                                           case 5: 
02331                                             MATCH_name = "SETb.NL"; 
02332                                             goto MATCH_label_c881; 
02333                                             
02334                                             break;
02335                                           default: assert(0);
02336                                         } /* (MATCH_w_8_16 & 0x7) 
02337                                               -- r_m at 16 --*/ 
02338                                       break;
02339                                     case 1: 
02340                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02341                                       if ((MATCH_w_8_16 & 0x7) 
02342                                               /* r_m at 16 */ == 4 && 
02343                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02344                                               /* index at 24 */ && 
02345                                         (MATCH_w_8_24 >> 3 & 0x7) 
02346                                               /* index at 24 */ < 8)) { 
02347                                         MATCH_name = "SETb.NL"; 
02348                                         { 
02349                                           char *name = MATCH_name;
02350                                           unsigned Eaddr = 
02351                                             2 + addressToPC(MATCH_p);
02352                                           nextPC = 5 + MATCH_p; 
02353                                           
02354 #line 272 "frontend/machine/pentium/decoder.m"
02355                                           
02356 
02357                                                 stmts = instantiate(pc, name, DIS_EADDR8);
02358 
02359                                                 SETS(name, DIS_EADDR8, BRANCH_JSGE)
02360 
02361                                           
02362                                           
02363                                           
02364                                         }
02365                                         
02366                                       } /*opt-block*/
02367                                       else { 
02368                                         MATCH_name = "SETb.NL"; 
02369                                         goto MATCH_label_c879; 
02370                                         
02371                                       } /*opt-block*/
02372                                       
02373                                       break;
02374                                     case 2: 
02375                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02376                                       if ((MATCH_w_8_16 & 0x7) 
02377                                               /* r_m at 16 */ == 4 && 
02378                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02379                                               /* index at 24 */ && 
02380                                         (MATCH_w_8_24 >> 3 & 0x7) 
02381                                               /* index at 24 */ < 8)) { 
02382                                         MATCH_name = "SETb.NL"; 
02383                                         goto MATCH_label_c880; 
02384                                         
02385                                       } /*opt-block*/
02386                                       else { 
02387                                         MATCH_name = "SETb.NL"; 
02388                                         goto MATCH_label_c881; 
02389                                         
02390                                       } /*opt-block*/
02391                                       
02392                                       break;
02393                                     case 3: 
02394                                       MATCH_name = "SETb.NL"; 
02395                                       goto MATCH_label_c878; 
02396                                       
02397                                       break;
02398                                     default: assert(0);
02399                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
02400                                         -- mod at 16 --*/ 
02401                                 
02402                                 break;
02403                               case 6: 
02404                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
02405                                 
02406                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
02407                                         /* mod at 16 */) {
02408                                     case 0: 
02409                                       
02410                                         switch((MATCH_w_8_16 & 0x7) 
02411                                               /* r_m at 16 */) {
02412                                           case 0: case 1: case 2: case 3: 
02413                                           case 6: case 7: 
02414                                             MATCH_name = "SETb.LE"; 
02415                                             goto MATCH_label_c882; 
02416                                             
02417                                             break;
02418                                           case 4: 
02419                                             MATCH_w_8_24 = 
02420                                               getByte(3 + MATCH_p); 
02421                                             if ((MATCH_w_8_24 & 0x7) 
02422                                                     /* base at 24 */ == 5 && 
02423                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02424                                                     /* index at 24 */ && 
02425                                               (MATCH_w_8_24 >> 3 & 0x7) 
02426                                                     /* index at 24 */ < 8)) { 
02427                                               MATCH_name = "SETb.LE"; 
02428                                               goto MATCH_label_c884; 
02429                                               
02430                                             } /*opt-block*/
02431                                             else { 
02432                                               MATCH_name = "SETb.LE"; 
02433                                               goto MATCH_label_c883; 
02434                                               
02435                                             } /*opt-block*/
02436                                             
02437                                             break;
02438                                           case 5: 
02439                                             MATCH_name = "SETb.LE"; 
02440                                             goto MATCH_label_c885; 
02441                                             
02442                                             break;
02443                                           default: assert(0);
02444                                         } /* (MATCH_w_8_16 & 0x7) 
02445                                               -- r_m at 16 --*/ 
02446                                       break;
02447                                     case 1: 
02448                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02449                                       if ((MATCH_w_8_16 & 0x7) 
02450                                               /* r_m at 16 */ == 4 && 
02451                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02452                                               /* index at 24 */ && 
02453                                         (MATCH_w_8_24 >> 3 & 0x7) 
02454                                               /* index at 24 */ < 8)) { 
02455                                         MATCH_name = "SETb.LE"; 
02456                                         { 
02457                                           char *name = MATCH_name;
02458                                           unsigned Eaddr = 
02459                                             2 + addressToPC(MATCH_p);
02460                                           nextPC = 5 + MATCH_p; 
02461                                           
02462 #line 269 "frontend/machine/pentium/decoder.m"
02463                                           
02464 
02465                                                 stmts = instantiate(pc, name, DIS_EADDR8);
02466 
02467                                                 SETS(name, DIS_EADDR8, BRANCH_JSLE)
02468 
02469                                           
02470                                           
02471                                           
02472                                         }
02473                                         
02474                                       } /*opt-block*/
02475                                       else { 
02476                                         MATCH_name = "SETb.LE"; 
02477                                         goto MATCH_label_c883; 
02478                                         
02479                                       } /*opt-block*/
02480                                       
02481                                       break;
02482                                     case 2: 
02483                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02484                                       if ((MATCH_w_8_16 & 0x7) 
02485                                               /* r_m at 16 */ == 4 && 
02486                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02487                                               /* index at 24 */ && 
02488                                         (MATCH_w_8_24 >> 3 & 0x7) 
02489                                               /* index at 24 */ < 8)) { 
02490                                         MATCH_name = "SETb.LE"; 
02491                                         goto MATCH_label_c884; 
02492                                         
02493                                       } /*opt-block*/
02494                                       else { 
02495                                         MATCH_name = "SETb.LE"; 
02496                                         goto MATCH_label_c885; 
02497                                         
02498                                       } /*opt-block*/
02499                                       
02500                                       break;
02501                                     case 3: 
02502                                       MATCH_name = "SETb.LE"; 
02503                                       goto MATCH_label_c882; 
02504                                       
02505                                       break;
02506                                     default: assert(0);
02507                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
02508                                         -- mod at 16 --*/ 
02509                                 
02510                                 break;
02511                               case 7: 
02512                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
02513                                 
02514                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
02515                                         /* mod at 16 */) {
02516                                     case 0: 
02517                                       
02518                                         switch((MATCH_w_8_16 & 0x7) 
02519                                               /* r_m at 16 */) {
02520                                           case 0: case 1: case 2: case 3: 
02521                                           case 6: case 7: 
02522                                             MATCH_name = "SETb.NLE"; 
02523                                             goto MATCH_label_c886; 
02524                                             
02525                                             break;
02526                                           case 4: 
02527                                             MATCH_w_8_24 = 
02528                                               getByte(3 + MATCH_p); 
02529                                             if ((MATCH_w_8_24 & 0x7) 
02530                                                     /* base at 24 */ == 5 && 
02531                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02532                                                     /* index at 24 */ && 
02533                                               (MATCH_w_8_24 >> 3 & 0x7) 
02534                                                     /* index at 24 */ < 8)) { 
02535                                               MATCH_name = "SETb.NLE"; 
02536                                               goto MATCH_label_c888; 
02537                                               
02538                                             } /*opt-block*/
02539                                             else { 
02540                                               MATCH_name = "SETb.NLE"; 
02541                                               goto MATCH_label_c887; 
02542                                               
02543                                             } /*opt-block*/
02544                                             
02545                                             break;
02546                                           case 5: 
02547                                             MATCH_name = "SETb.NLE"; 
02548                                             goto MATCH_label_c889; 
02549                                             
02550                                             break;
02551                                           default: assert(0);
02552                                         } /* (MATCH_w_8_16 & 0x7) 
02553                                               -- r_m at 16 --*/ 
02554                                       break;
02555                                     case 1: 
02556                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02557                                       if ((MATCH_w_8_16 & 0x7) 
02558                                               /* r_m at 16 */ == 4 && 
02559                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02560                                               /* index at 24 */ && 
02561                                         (MATCH_w_8_24 >> 3 & 0x7) 
02562                                               /* index at 24 */ < 8)) { 
02563                                         MATCH_name = "SETb.NLE"; 
02564                                         { 
02565                                           char *name = MATCH_name;
02566                                           unsigned Eaddr = 
02567                                             2 + addressToPC(MATCH_p);
02568                                           nextPC = 5 + MATCH_p; 
02569                                           
02570 #line 266 "frontend/machine/pentium/decoder.m"
02571                                           
02572 
02573                                                 stmts = instantiate(pc, name, DIS_EADDR8);
02574 
02575                                                 SETS(name, DIS_EADDR8, BRANCH_JSG)
02576 
02577                                           
02578                                           
02579                                           
02580                                         }
02581                                         
02582                                       } /*opt-block*/
02583                                       else { 
02584                                         MATCH_name = "SETb.NLE"; 
02585                                         goto MATCH_label_c887; 
02586                                         
02587                                       } /*opt-block*/
02588                                       
02589                                       break;
02590                                     case 2: 
02591                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02592                                       if ((MATCH_w_8_16 & 0x7) 
02593                                               /* r_m at 16 */ == 4 && 
02594                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02595                                               /* index at 24 */ && 
02596                                         (MATCH_w_8_24 >> 3 & 0x7) 
02597                                               /* index at 24 */ < 8)) { 
02598                                         MATCH_name = "SETb.NLE"; 
02599                                         goto MATCH_label_c888; 
02600                                         
02601                                       } /*opt-block*/
02602                                       else { 
02603                                         MATCH_name = "SETb.NLE"; 
02604                                         goto MATCH_label_c889; 
02605                                         
02606                                       } /*opt-block*/
02607                                       
02608                                       break;
02609                                     case 3: 
02610                                       MATCH_name = "SETb.NLE"; 
02611                                       goto MATCH_label_c886; 
02612                                       
02613                                       break;
02614                                     default: assert(0);
02615                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
02616                                         -- mod at 16 --*/ 
02617                                 
02618                                 break;
02619                               default: assert(0);
02620                             } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/  
02621                         else 
02622                           
02623                             switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
02624                               case 0: case 1: 
02625                                 goto MATCH_label_c64; break;
02626                               case 2: 
02627                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
02628                                 
02629                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
02630                                         /* mod at 16 */) {
02631                                     case 0: 
02632                                       
02633                                         switch((MATCH_w_8_16 & 0x7) 
02634                                               /* r_m at 16 */) {
02635                                           case 0: case 1: case 2: case 3: 
02636                                           case 6: case 7: 
02637                                             MATCH_name = "SETb.B"; 
02638                                             goto MATCH_label_c842; 
02639                                             
02640                                             break;
02641                                           case 4: 
02642                                             MATCH_w_8_24 = 
02643                                               getByte(3 + MATCH_p); 
02644                                             if ((MATCH_w_8_24 & 0x7) 
02645                                                     /* base at 24 */ == 5 && 
02646                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02647                                                     /* index at 24 */ && 
02648                                               (MATCH_w_8_24 >> 3 & 0x7) 
02649                                                     /* index at 24 */ < 8)) { 
02650                                               MATCH_name = "SETb.B"; 
02651                                               goto MATCH_label_c844; 
02652                                               
02653                                             } /*opt-block*/
02654                                             else { 
02655                                               MATCH_name = "SETb.B"; 
02656                                               goto MATCH_label_c843; 
02657                                               
02658                                             } /*opt-block*/
02659                                             
02660                                             break;
02661                                           case 5: 
02662                                             MATCH_name = "SETb.B"; 
02663                                             goto MATCH_label_c845; 
02664                                             
02665                                             break;
02666                                           default: assert(0);
02667                                         } /* (MATCH_w_8_16 & 0x7) 
02668                                               -- r_m at 16 --*/ 
02669                                       break;
02670                                     case 1: 
02671                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02672                                       if ((MATCH_w_8_16 & 0x7) 
02673                                               /* r_m at 16 */ == 4 && 
02674                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02675                                               /* index at 24 */ && 
02676                                         (MATCH_w_8_24 >> 3 & 0x7) 
02677                                               /* index at 24 */ < 8)) { 
02678                                         MATCH_name = "SETb.B"; 
02679                                         { 
02680                                           char *name = MATCH_name;
02681                                           unsigned Eaddr = 
02682                                             2 + addressToPC(MATCH_p);
02683                                           nextPC = 5 + MATCH_p; 
02684                                           
02685 #line 305 "frontend/machine/pentium/decoder.m"
02686                                           
02687 
02688                                                 stmts = instantiate(pc, name, DIS_EADDR8);
02689 
02690                                                 SETS(name, DIS_EADDR8, BRANCH_JUL)
02691 
02692                                             //| SETb.NO(Eaddr) [name] =>
02693 
02694                                             //  stmts = instantiate(pc, name, DIS_EADDR8);
02695 
02696                                             //  SETS(name, DIS_EADDR8, BRANCH_JSG)
02697 
02698                                             //| SETb.O(Eaddr) [name] =>
02699 
02700                                             //  stmts = instantiate(pc, name, DIS_EADDR8);
02701 
02702                                             //  SETS(name, DIS_EADDR8, BRANCH_JSG)
02703 
02704                                           
02705 
02706                                           
02707                                           
02708                                           
02709                                         }
02710                                         
02711                                       } /*opt-block*/
02712                                       else { 
02713                                         MATCH_name = "SETb.B"; 
02714                                         goto MATCH_label_c843; 
02715                                         
02716                                       } /*opt-block*/
02717                                       
02718                                       break;
02719                                     case 2: 
02720                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02721                                       if ((MATCH_w_8_16 & 0x7) 
02722                                               /* r_m at 16 */ == 4 && 
02723                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02724                                               /* index at 24 */ && 
02725                                         (MATCH_w_8_24 >> 3 & 0x7) 
02726                                               /* index at 24 */ < 8)) { 
02727                                         MATCH_name = "SETb.B"; 
02728                                         goto MATCH_label_c844; 
02729                                         
02730                                       } /*opt-block*/
02731                                       else { 
02732                                         MATCH_name = "SETb.B"; 
02733                                         goto MATCH_label_c845; 
02734                                         
02735                                       } /*opt-block*/
02736                                       
02737                                       break;
02738                                     case 3: 
02739                                       MATCH_name = "SETb.B"; 
02740                                       goto MATCH_label_c842; 
02741                                       
02742                                       break;
02743                                     default: assert(0);
02744                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
02745                                         -- mod at 16 --*/ 
02746                                 
02747                                 break;
02748                               case 3: 
02749                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
02750                                 
02751                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
02752                                         /* mod at 16 */) {
02753                                     case 0: 
02754                                       
02755                                         switch((MATCH_w_8_16 & 0x7) 
02756                                               /* r_m at 16 */) {
02757                                           case 0: case 1: case 2: case 3: 
02758                                           case 6: case 7: 
02759                                             MATCH_name = "SETb.NB"; 
02760                                             goto MATCH_label_c846; 
02761                                             
02762                                             break;
02763                                           case 4: 
02764                                             MATCH_w_8_24 = 
02765                                               getByte(3 + MATCH_p); 
02766                                             if ((MATCH_w_8_24 & 0x7) 
02767                                                     /* base at 24 */ == 5 && 
02768                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02769                                                     /* index at 24 */ && 
02770                                               (MATCH_w_8_24 >> 3 & 0x7) 
02771                                                     /* index at 24 */ < 8)) { 
02772                                               MATCH_name = "SETb.NB"; 
02773                                               goto MATCH_label_c848; 
02774                                               
02775                                             } /*opt-block*/
02776                                             else { 
02777                                               MATCH_name = "SETb.NB"; 
02778                                               goto MATCH_label_c847; 
02779                                               
02780                                             } /*opt-block*/
02781                                             
02782                                             break;
02783                                           case 5: 
02784                                             MATCH_name = "SETb.NB"; 
02785                                             goto MATCH_label_c849; 
02786                                             
02787                                             break;
02788                                           default: assert(0);
02789                                         } /* (MATCH_w_8_16 & 0x7) 
02790                                               -- r_m at 16 --*/ 
02791                                       break;
02792                                     case 1: 
02793                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02794                                       if ((MATCH_w_8_16 & 0x7) 
02795                                               /* r_m at 16 */ == 4 && 
02796                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02797                                               /* index at 24 */ && 
02798                                         (MATCH_w_8_24 >> 3 & 0x7) 
02799                                               /* index at 24 */ < 8)) { 
02800                                         MATCH_name = "SETb.NB"; 
02801                                         { 
02802                                           char *name = MATCH_name;
02803                                           unsigned Eaddr = 
02804                                             2 + addressToPC(MATCH_p);
02805                                           nextPC = 5 + MATCH_p; 
02806                                           
02807 #line 302 "frontend/machine/pentium/decoder.m"
02808                                           
02809 
02810                                                 stmts = instantiate(pc, name, DIS_EADDR8);
02811 
02812                                                 SETS(name, DIS_EADDR8, BRANCH_JUGE)
02813 
02814                                           
02815                                           
02816                                           
02817                                         }
02818                                         
02819                                       } /*opt-block*/
02820                                       else { 
02821                                         MATCH_name = "SETb.NB"; 
02822                                         goto MATCH_label_c847; 
02823                                         
02824                                       } /*opt-block*/
02825                                       
02826                                       break;
02827                                     case 2: 
02828                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02829                                       if ((MATCH_w_8_16 & 0x7) 
02830                                               /* r_m at 16 */ == 4 && 
02831                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02832                                               /* index at 24 */ && 
02833                                         (MATCH_w_8_24 >> 3 & 0x7) 
02834                                               /* index at 24 */ < 8)) { 
02835                                         MATCH_name = "SETb.NB"; 
02836                                         goto MATCH_label_c848; 
02837                                         
02838                                       } /*opt-block*/
02839                                       else { 
02840                                         MATCH_name = "SETb.NB"; 
02841                                         goto MATCH_label_c849; 
02842                                         
02843                                       } /*opt-block*/
02844                                       
02845                                       break;
02846                                     case 3: 
02847                                       MATCH_name = "SETb.NB"; 
02848                                       goto MATCH_label_c846; 
02849                                       
02850                                       break;
02851                                     default: assert(0);
02852                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
02853                                         -- mod at 16 --*/ 
02854                                 
02855                                 break;
02856                               case 4: 
02857                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
02858                                 
02859                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
02860                                         /* mod at 16 */) {
02861                                     case 0: 
02862                                       
02863                                         switch((MATCH_w_8_16 & 0x7) 
02864                                               /* r_m at 16 */) {
02865                                           case 0: case 1: case 2: case 3: 
02866                                           case 6: case 7: 
02867                                             MATCH_name = "SETb.Z"; 
02868                                             goto MATCH_label_c850; 
02869                                             
02870                                             break;
02871                                           case 4: 
02872                                             MATCH_w_8_24 = 
02873                                               getByte(3 + MATCH_p); 
02874                                             if ((MATCH_w_8_24 & 0x7) 
02875                                                     /* base at 24 */ == 5 && 
02876                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02877                                                     /* index at 24 */ && 
02878                                               (MATCH_w_8_24 >> 3 & 0x7) 
02879                                                     /* index at 24 */ < 8)) { 
02880                                               MATCH_name = "SETb.Z"; 
02881                                               goto MATCH_label_c852; 
02882                                               
02883                                             } /*opt-block*/
02884                                             else { 
02885                                               MATCH_name = "SETb.Z"; 
02886                                               goto MATCH_label_c851; 
02887                                               
02888                                             } /*opt-block*/
02889                                             
02890                                             break;
02891                                           case 5: 
02892                                             MATCH_name = "SETb.Z"; 
02893                                             goto MATCH_label_c853; 
02894                                             
02895                                             break;
02896                                           default: assert(0);
02897                                         } /* (MATCH_w_8_16 & 0x7) 
02898                                               -- r_m at 16 --*/ 
02899                                       break;
02900                                     case 1: 
02901                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02902                                       if ((MATCH_w_8_16 & 0x7) 
02903                                               /* r_m at 16 */ == 4 && 
02904                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02905                                               /* index at 24 */ && 
02906                                         (MATCH_w_8_24 >> 3 & 0x7) 
02907                                               /* index at 24 */ < 8)) { 
02908                                         MATCH_name = "SETb.Z"; 
02909                                         { 
02910                                           char *name = MATCH_name;
02911                                           unsigned Eaddr = 
02912                                             2 + addressToPC(MATCH_p);
02913                                           nextPC = 5 + MATCH_p; 
02914                                           
02915 #line 299 "frontend/machine/pentium/decoder.m"
02916                                           
02917 
02918                                                 stmts = instantiate(pc, name, DIS_EADDR8);
02919 
02920                                                 SETS(name, DIS_EADDR8, BRANCH_JE)
02921 
02922                                           
02923                                           
02924                                           
02925                                         }
02926                                         
02927                                       } /*opt-block*/
02928                                       else { 
02929                                         MATCH_name = "SETb.Z"; 
02930                                         goto MATCH_label_c851; 
02931                                         
02932                                       } /*opt-block*/
02933                                       
02934                                       break;
02935                                     case 2: 
02936                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02937                                       if ((MATCH_w_8_16 & 0x7) 
02938                                               /* r_m at 16 */ == 4 && 
02939                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02940                                               /* index at 24 */ && 
02941                                         (MATCH_w_8_24 >> 3 & 0x7) 
02942                                               /* index at 24 */ < 8)) { 
02943                                         MATCH_name = "SETb.Z"; 
02944                                         goto MATCH_label_c852; 
02945                                         
02946                                       } /*opt-block*/
02947                                       else { 
02948                                         MATCH_name = "SETb.Z"; 
02949                                         goto MATCH_label_c853; 
02950                                         
02951                                       } /*opt-block*/
02952                                       
02953                                       break;
02954                                     case 3: 
02955                                       MATCH_name = "SETb.Z"; 
02956                                       goto MATCH_label_c850; 
02957                                       
02958                                       break;
02959                                     default: assert(0);
02960                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
02961                                         -- mod at 16 --*/ 
02962                                 
02963                                 break;
02964                               case 5: 
02965                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
02966                                 
02967                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
02968                                         /* mod at 16 */) {
02969                                     case 0: 
02970                                       
02971                                         switch((MATCH_w_8_16 & 0x7) 
02972                                               /* r_m at 16 */) {
02973                                           case 0: case 1: case 2: case 3: 
02974                                           case 6: case 7: 
02975                                             MATCH_name = "SETb.NZ"; 
02976                                             goto MATCH_label_c854; 
02977                                             
02978                                             break;
02979                                           case 4: 
02980                                             MATCH_w_8_24 = 
02981                                               getByte(3 + MATCH_p); 
02982                                             if ((MATCH_w_8_24 & 0x7) 
02983                                                     /* base at 24 */ == 5 && 
02984                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02985                                                     /* index at 24 */ && 
02986                                               (MATCH_w_8_24 >> 3 & 0x7) 
02987                                                     /* index at 24 */ < 8)) { 
02988                                               MATCH_name = "SETb.NZ"; 
02989                                               goto MATCH_label_c856; 
02990                                               
02991                                             } /*opt-block*/
02992                                             else { 
02993                                               MATCH_name = "SETb.NZ"; 
02994                                               goto MATCH_label_c855; 
02995                                               
02996                                             } /*opt-block*/
02997                                             
02998                                             break;
02999                                           case 5: 
03000                                             MATCH_name = "SETb.NZ"; 
03001                                             goto MATCH_label_c857; 
03002                                             
03003                                             break;
03004                                           default: assert(0);
03005                                         } /* (MATCH_w_8_16 & 0x7) 
03006                                               -- r_m at 16 --*/ 
03007                                       break;
03008                                     case 1: 
03009                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03010                                       if ((MATCH_w_8_16 & 0x7) 
03011                                               /* r_m at 16 */ == 4 && 
03012                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03013                                               /* index at 24 */ && 
03014                                         (MATCH_w_8_24 >> 3 & 0x7) 
03015                                               /* index at 24 */ < 8)) { 
03016                                         MATCH_name = "SETb.NZ"; 
03017                                         { 
03018                                           char *name = MATCH_name;
03019                                           unsigned Eaddr = 
03020                                             2 + addressToPC(MATCH_p);
03021                                           nextPC = 5 + MATCH_p; 
03022                                           
03023 #line 296 "frontend/machine/pentium/decoder.m"
03024                                           
03025 
03026                                                 stmts = instantiate(pc, name, DIS_EADDR8);
03027 
03028                                                 SETS(name, DIS_EADDR8, BRANCH_JNE)
03029 
03030                                           
03031                                           
03032                                           
03033                                         }
03034                                         
03035                                       } /*opt-block*/
03036                                       else { 
03037                                         MATCH_name = "SETb.NZ"; 
03038                                         goto MATCH_label_c855; 
03039                                         
03040                                       } /*opt-block*/
03041                                       
03042                                       break;
03043                                     case 2: 
03044                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03045                                       if ((MATCH_w_8_16 & 0x7) 
03046                                               /* r_m at 16 */ == 4 && 
03047                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03048                                               /* index at 24 */ && 
03049                                         (MATCH_w_8_24 >> 3 & 0x7) 
03050                                               /* index at 24 */ < 8)) { 
03051                                         MATCH_name = "SETb.NZ"; 
03052                                         goto MATCH_label_c856; 
03053                                         
03054                                       } /*opt-block*/
03055                                       else { 
03056                                         MATCH_name = "SETb.NZ"; 
03057                                         goto MATCH_label_c857; 
03058                                         
03059                                       } /*opt-block*/
03060                                       
03061                                       break;
03062                                     case 3: 
03063                                       MATCH_name = "SETb.NZ"; 
03064                                       goto MATCH_label_c854; 
03065                                       
03066                                       break;
03067                                     default: assert(0);
03068                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03069                                         -- mod at 16 --*/ 
03070                                 
03071                                 break;
03072                               case 6: 
03073                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03074                                 
03075                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03076                                         /* mod at 16 */) {
03077                                     case 0: 
03078                                       
03079                                         switch((MATCH_w_8_16 & 0x7) 
03080                                               /* r_m at 16 */) {
03081                                           case 0: case 1: case 2: case 3: 
03082                                           case 6: case 7: 
03083                                             MATCH_name = "SETb.BE"; 
03084                                             goto MATCH_label_c858; 
03085                                             
03086                                             break;
03087                                           case 4: 
03088                                             MATCH_w_8_24 = 
03089                                               getByte(3 + MATCH_p); 
03090                                             if ((MATCH_w_8_24 & 0x7) 
03091                                                     /* base at 24 */ == 5 && 
03092                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03093                                                     /* index at 24 */ && 
03094                                               (MATCH_w_8_24 >> 3 & 0x7) 
03095                                                     /* index at 24 */ < 8)) { 
03096                                               MATCH_name = "SETb.BE"; 
03097                                               goto MATCH_label_c860; 
03098                                               
03099                                             } /*opt-block*/
03100                                             else { 
03101                                               MATCH_name = "SETb.BE"; 
03102                                               goto MATCH_label_c859; 
03103                                               
03104                                             } /*opt-block*/
03105                                             
03106                                             break;
03107                                           case 5: 
03108                                             MATCH_name = "SETb.BE"; 
03109                                             goto MATCH_label_c861; 
03110                                             
03111                                             break;
03112                                           default: assert(0);
03113                                         } /* (MATCH_w_8_16 & 0x7) 
03114                                               -- r_m at 16 --*/ 
03115                                       break;
03116                                     case 1: 
03117                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03118                                       if ((MATCH_w_8_16 & 0x7) 
03119                                               /* r_m at 16 */ == 4 && 
03120                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03121                                               /* index at 24 */ && 
03122                                         (MATCH_w_8_24 >> 3 & 0x7) 
03123                                               /* index at 24 */ < 8)) { 
03124                                         MATCH_name = "SETb.BE"; 
03125                                         { 
03126                                           char *name = MATCH_name;
03127                                           unsigned Eaddr = 
03128                                             2 + addressToPC(MATCH_p);
03129                                           nextPC = 5 + MATCH_p; 
03130                                           
03131 #line 293 "frontend/machine/pentium/decoder.m"
03132                                           
03133 
03134                                                 stmts = instantiate(pc, name, DIS_EADDR8);
03135 
03136                                                 SETS(name, DIS_EADDR8, BRANCH_JULE)
03137 
03138                                           
03139                                           
03140                                           
03141                                         }
03142                                         
03143                                       } /*opt-block*/
03144                                       else { 
03145                                         MATCH_name = "SETb.BE"; 
03146                                         goto MATCH_label_c859; 
03147                                         
03148                                       } /*opt-block*/
03149                                       
03150                                       break;
03151                                     case 2: 
03152                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03153                                       if ((MATCH_w_8_16 & 0x7) 
03154                                               /* r_m at 16 */ == 4 && 
03155                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03156                                               /* index at 24 */ && 
03157                                         (MATCH_w_8_24 >> 3 & 0x7) 
03158                                               /* index at 24 */ < 8)) { 
03159                                         MATCH_name = "SETb.BE"; 
03160                                         goto MATCH_label_c860; 
03161                                         
03162                                       } /*opt-block*/
03163                                       else { 
03164                                         MATCH_name = "SETb.BE"; 
03165                                         goto MATCH_label_c861; 
03166                                         
03167                                       } /*opt-block*/
03168                                       
03169                                       break;
03170                                     case 3: 
03171                                       MATCH_name = "SETb.BE"; 
03172                                       goto MATCH_label_c858; 
03173                                       
03174                                       break;
03175                                     default: assert(0);
03176                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03177                                         -- mod at 16 --*/ 
03178                                 
03179                                 break;
03180                               case 7: 
03181                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03182                                 
03183                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03184                                         /* mod at 16 */) {
03185                                     case 0: 
03186                                       
03187                                         switch((MATCH_w_8_16 & 0x7) 
03188                                               /* r_m at 16 */) {
03189                                           case 0: case 1: case 2: case 3: 
03190                                           case 6: case 7: 
03191                                             MATCH_name = "SETb.NBE"; 
03192                                             goto MATCH_label_c862; 
03193                                             
03194                                             break;
03195                                           case 4: 
03196                                             MATCH_w_8_24 = 
03197                                               getByte(3 + MATCH_p); 
03198                                             if ((MATCH_w_8_24 & 0x7) 
03199                                                     /* base at 24 */ == 5 && 
03200                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03201                                                     /* index at 24 */ && 
03202                                               (MATCH_w_8_24 >> 3 & 0x7) 
03203                                                     /* index at 24 */ < 8)) { 
03204                                               MATCH_name = "SETb.NBE"; 
03205                                               goto MATCH_label_c864; 
03206                                               
03207                                             } /*opt-block*/
03208                                             else { 
03209                                               MATCH_name = "SETb.NBE"; 
03210                                               goto MATCH_label_c863; 
03211                                               
03212                                             } /*opt-block*/
03213                                             
03214                                             break;
03215                                           case 5: 
03216                                             MATCH_name = "SETb.NBE"; 
03217                                             goto MATCH_label_c865; 
03218                                             
03219                                             break;
03220                                           default: assert(0);
03221                                         } /* (MATCH_w_8_16 & 0x7) 
03222                                               -- r_m at 16 --*/ 
03223                                       break;
03224                                     case 1: 
03225                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03226                                       if ((MATCH_w_8_16 & 0x7) 
03227                                               /* r_m at 16 */ == 4 && 
03228                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03229                                               /* index at 24 */ && 
03230                                         (MATCH_w_8_24 >> 3 & 0x7) 
03231                                               /* index at 24 */ < 8)) { 
03232                                         MATCH_name = "SETb.NBE"; 
03233                                         { 
03234                                           char *name = MATCH_name;
03235                                           unsigned Eaddr = 
03236                                             2 + addressToPC(MATCH_p);
03237                                           nextPC = 5 + MATCH_p; 
03238                                           
03239 #line 290 "frontend/machine/pentium/decoder.m"
03240                                           
03241 
03242                                                 stmts = instantiate(pc, name, DIS_EADDR8);
03243 
03244                                                 SETS(name, DIS_EADDR8, BRANCH_JUG)
03245 
03246                                           
03247                                           
03248                                           
03249                                         }
03250                                         
03251                                       } /*opt-block*/
03252                                       else { 
03253                                         MATCH_name = "SETb.NBE"; 
03254                                         goto MATCH_label_c863; 
03255                                         
03256                                       } /*opt-block*/
03257                                       
03258                                       break;
03259                                     case 2: 
03260                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03261                                       if ((MATCH_w_8_16 & 0x7) 
03262                                               /* r_m at 16 */ == 4 && 
03263                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03264                                               /* index at 24 */ && 
03265                                         (MATCH_w_8_24 >> 3 & 0x7) 
03266                                               /* index at 24 */ < 8)) { 
03267                                         MATCH_name = "SETb.NBE"; 
03268                                         goto MATCH_label_c864; 
03269                                         
03270                                       } /*opt-block*/
03271                                       else { 
03272                                         MATCH_name = "SETb.NBE"; 
03273                                         goto MATCH_label_c865; 
03274                                         
03275                                       } /*opt-block*/
03276                                       
03277                                       break;
03278                                     case 3: 
03279                                       MATCH_name = "SETb.NBE"; 
03280                                       goto MATCH_label_c862; 
03281                                       
03282                                       break;
03283                                     default: assert(0);
03284                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03285                                         -- mod at 16 --*/ 
03286                                 
03287                                 break;
03288                               default: assert(0);
03289                             } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/  
03290                         break;
03291                       case 10: 
03292                         
03293                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
03294                             case 0: 
03295                               if ((MATCH_w_8_8 >> 3 & 0x1) 
03296                                       /* page at 8 */ == 1) { 
03297                                 nextPC = 2 + MATCH_p; 
03298                                 
03299 #line 802 "frontend/machine/pentium/decoder.m"
03300                                 
03301 
03302                                         stmts = instantiate(pc,  "PUSH.GS");
03303 
03304                                 
03305 
03306                                 
03307                                 
03308                                 
03309                               } /*opt-block*//*opt-block+*/
03310                               else { 
03311                                 nextPC = 2 + MATCH_p; 
03312                                 
03313 #line 805 "frontend/machine/pentium/decoder.m"
03314                                 
03315 
03316                                         stmts = instantiate(pc,  "PUSH.FS");
03317 
03318                                 
03319 
03320                                 
03321                                 
03322                                 
03323                               } /*opt-block*//*opt-block+*/
03324                               
03325                               break;
03326                             case 1: 
03327                               if ((MATCH_w_8_8 >> 3 & 0x1) 
03328                                       /* page at 8 */ == 1) { 
03329                                 nextPC = 2 + MATCH_p; 
03330                                 
03331 #line 856 "frontend/machine/pentium/decoder.m"
03332                                 
03333 
03334                                         stmts = instantiate(pc,  "POP.GS");
03335 
03336                                 
03337 
03338                                 
03339                                 
03340                                 
03341                               } /*opt-block*//*opt-block+*/
03342                               else { 
03343                                 nextPC = 2 + MATCH_p; 
03344                                 
03345 #line 859 "frontend/machine/pentium/decoder.m"
03346                                 
03347 
03348                                         stmts = instantiate(pc,  "POP.FS");
03349 
03350                                 
03351 
03352                                 
03353                                 
03354                                 
03355                               } /*opt-block*//*opt-block+*/
03356                               
03357                               break;
03358                             case 2: 
03359                               if ((MATCH_w_8_8 >> 3 & 0x1) 
03360                                       /* page at 8 */ == 1) { 
03361                                 nextPC = 2 + MATCH_p; 
03362                                 
03363 #line 475 "frontend/machine/pentium/decoder.m"
03364                                 
03365 
03366                                         stmts = instantiate(pc,  "RSM");
03367 
03368                                 
03369 
03370                                 
03371                                 
03372                                 
03373                               } /*opt-block*//*opt-block+*/
03374                               else { 
03375                                 nextPC = 2 + MATCH_p; 
03376                                 
03377 #line 1232 "frontend/machine/pentium/decoder.m"
03378                                 
03379 
03380                                         stmts = instantiate(pc,  "CPUID");
03381 
03382                                 
03383 
03384                                 
03385                                 
03386                                 
03387                               } /*opt-block*//*opt-block+*/
03388                               
03389                               break;
03390                             case 3: 
03391                               if ((MATCH_w_8_8 >> 3 & 0x1) 
03392                                       /* page at 8 */ == 1) { 
03393                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03394                                 
03395                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03396                                         /* mod at 16 */) {
03397                                     case 0: 
03398                                       
03399                                         switch((MATCH_w_8_16 & 0x7) 
03400                                               /* r_m at 16 */) {
03401                                           case 0: case 1: case 2: case 3: 
03402                                           case 6: case 7: 
03403                                             goto MATCH_label_c894; break;
03404                                           case 4: 
03405                                             MATCH_w_8_24 = 
03406                                               getByte(3 + MATCH_p); 
03407                                             if ((MATCH_w_8_24 & 0x7) 
03408                                                     /* base at 24 */ == 5 && 
03409                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03410                                                     /* index at 24 */ && 
03411                                               (MATCH_w_8_24 >> 3 & 0x7) 
03412                                                     /* index at 24 */ < 8)) 
03413                                               goto MATCH_label_c896;  /*opt-block+*/
03414                                             else 
03415                                               goto MATCH_label_c895;  /*opt-block+*/
03416                                             
03417                                             break;
03418                                           case 5: 
03419                                             goto MATCH_label_c897; break;
03420                                           default: assert(0);
03421                                         } /* (MATCH_w_8_16 & 0x7) 
03422                                               -- r_m at 16 --*/ 
03423                                       break;
03424                                     case 1: 
03425                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03426                                       if ((MATCH_w_8_16 & 0x7) 
03427                                               /* r_m at 16 */ == 4 && 
03428                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03429                                               /* index at 24 */ && 
03430                                         (MATCH_w_8_24 >> 3 & 0x7) 
03431                                               /* index at 24 */ < 8)) { 
03432                                         unsigned Eaddr = 
03433                                           2 + addressToPC(MATCH_p);
03434                                         unsigned reg = 
03435                                           (MATCH_w_8_16 >> 3 & 0x7) 
03436                                                 /* reg_opcode at 16 */;
03437                                         nextPC = 5 + MATCH_p; 
03438                                         
03439 #line 1316 "frontend/machine/pentium/decoder.m"
03440                                         
03441 
03442                                                 stmts = instantiate(pc,  "BTSod", DIS_EADDR32, DIS_REG32);
03443 
03444                                         
03445 
03446                                         
03447                                         
03448                                         
03449                                       } /*opt-block*//*opt-block+*/
03450                                       else 
03451                                         goto MATCH_label_c895;  /*opt-block+*/
03452                                       
03453                                       break;
03454                                     case 2: 
03455                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03456                                       if ((MATCH_w_8_16 & 0x7) 
03457                                               /* r_m at 16 */ == 4 && 
03458                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03459                                               /* index at 24 */ && 
03460                                         (MATCH_w_8_24 >> 3 & 0x7) 
03461                                               /* index at 24 */ < 8)) 
03462                                         goto MATCH_label_c896;  /*opt-block+*/
03463                                       else 
03464                                         goto MATCH_label_c897;  /*opt-block+*/
03465                                       
03466                                       break;
03467                                     case 3: 
03468                                       goto MATCH_label_c894; break;
03469                                     default: assert(0);
03470                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03471                                         -- mod at 16 --*/ 
03472                                 
03473                               } /*opt-block*/
03474                               else { 
03475                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03476                                 
03477                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03478                                         /* mod at 16 */) {
03479                                     case 0: 
03480                                       
03481                                         switch((MATCH_w_8_16 & 0x7) 
03482                                               /* r_m at 16 */) {
03483                                           case 0: case 1: case 2: case 3: 
03484                                           case 6: case 7: 
03485                                             goto MATCH_label_c890; break;
03486                                           case 4: 
03487                                             MATCH_w_8_24 = 
03488                                               getByte(3 + MATCH_p); 
03489                                             if ((MATCH_w_8_24 & 0x7) 
03490                                                     /* base at 24 */ == 5 && 
03491                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03492                                                     /* index at 24 */ && 
03493                                               (MATCH_w_8_24 >> 3 & 0x7) 
03494                                                     /* index at 24 */ < 8)) 
03495                                               goto MATCH_label_c892;  /*opt-block+*/
03496                                             else 
03497                                               goto MATCH_label_c891;  /*opt-block+*/
03498                                             
03499                                             break;
03500                                           case 5: 
03501                                             goto MATCH_label_c893; break;
03502                                           default: assert(0);
03503                                         } /* (MATCH_w_8_16 & 0x7) 
03504                                               -- r_m at 16 --*/ 
03505                                       break;
03506                                     case 1: 
03507                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03508                                       if ((MATCH_w_8_16 & 0x7) 
03509                                               /* r_m at 16 */ == 4 && 
03510                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03511                                               /* index at 24 */ && 
03512                                         (MATCH_w_8_24 >> 3 & 0x7) 
03513                                               /* index at 24 */ < 8)) { 
03514                                         unsigned Eaddr = 
03515                                           2 + addressToPC(MATCH_p);
03516                                         unsigned reg = 
03517                                           (MATCH_w_8_16 >> 3 & 0x7) 
03518                                                 /* reg_opcode at 16 */;
03519                                         nextPC = 5 + MATCH_p; 
03520                                         
03521 #line 1352 "frontend/machine/pentium/decoder.m"
03522                                         
03523 
03524                                                 stmts = instantiate(pc,  "BTod", DIS_EADDR32, DIS_REG32);
03525 
03526                                         
03527 
03528                                         
03529                                         
03530                                         
03531                                       } /*opt-block*//*opt-block+*/
03532                                       else 
03533                                         goto MATCH_label_c891;  /*opt-block+*/
03534                                       
03535                                       break;
03536                                     case 2: 
03537                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03538                                       if ((MATCH_w_8_16 & 0x7) 
03539                                               /* r_m at 16 */ == 4 && 
03540                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03541                                               /* index at 24 */ && 
03542                                         (MATCH_w_8_24 >> 3 & 0x7) 
03543                                               /* index at 24 */ < 8)) 
03544                                         goto MATCH_label_c892;  /*opt-block+*/
03545                                       else 
03546                                         goto MATCH_label_c893;  /*opt-block+*/
03547                                       
03548                                       break;
03549                                     case 3: 
03550                                       goto MATCH_label_c890; break;
03551                                     default: assert(0);
03552                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03553                                         -- mod at 16 --*/ 
03554                                 
03555                               } /*opt-block*/
03556                               break;
03557                             case 4: 
03558                               if ((MATCH_w_8_8 >> 3 & 0x1) 
03559                                       /* page at 8 */ == 1) { 
03560                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03561                                 
03562                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03563                                         /* mod at 16 */) {
03564                                     case 0: 
03565                                       
03566                                         switch((MATCH_w_8_16 & 0x7) 
03567                                               /* r_m at 16 */) {
03568                                           case 0: case 1: case 2: case 3: 
03569                                           case 6: case 7: 
03570                                             MATCH_w_8_24 = 
03571                                               getByte(3 + MATCH_p); 
03572                                             goto MATCH_label_c902; 
03573                                             
03574                                             break;
03575                                           case 4: 
03576                                             MATCH_w_8_24 = 
03577                                               getByte(3 + MATCH_p); 
03578                                             if ((MATCH_w_8_24 & 0x7) 
03579                                                     /* base at 24 */ == 5 && 
03580                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03581                                                     /* index at 24 */ && 
03582                                               (MATCH_w_8_24 >> 3 & 0x7) 
03583                                                     /* index at 24 */ < 8)) { 
03584                                               MATCH_w_8_64 = 
03585                                                 getByte(8 + MATCH_p); 
03586                                               goto MATCH_label_c904; 
03587                                               
03588                                             } /*opt-block*/
03589                                             else { 
03590                                               MATCH_w_8_32 = 
03591                                                 getByte(4 + MATCH_p); 
03592                                               goto MATCH_label_c903; 
03593                                               
03594                                             } /*opt-block*/
03595                                             
03596                                             break;
03597                                           case 5: 
03598                                             MATCH_w_8_56 = 
03599                                               getByte(7 + MATCH_p); 
03600                                             goto MATCH_label_c905; 
03601                                             
03602                                             break;
03603                                           default: assert(0);
03604                                         } /* (MATCH_w_8_16 & 0x7) 
03605                                               -- r_m at 16 --*/ 
03606                                       break;
03607                                     case 1: 
03608                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03609                                       if ((MATCH_w_8_16 & 0x7) 
03610                                               /* r_m at 16 */ == 4 && 
03611                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03612                                               /* index at 24 */ && 
03613                                         (MATCH_w_8_24 >> 3 & 0x7) 
03614                                               /* index at 24 */ < 8)) { 
03615                                         MATCH_w_8_40 = getByte(5 + MATCH_p); 
03616                                         { 
03617                                           unsigned Eaddr = 
03618                                             2 + addressToPC(MATCH_p);
03619                                           unsigned count = 
03620                                             (MATCH_w_8_40 & 0xff) 
03621                                                   /* i8 at 40 */;
03622                                           unsigned reg = 
03623                                             (MATCH_w_8_16 >> 3 & 0x7) 
03624                                                   /* reg_opcode at 16 */;
03625                                           nextPC = 6 + MATCH_p; 
03626                                           
03627 #line 450 "frontend/machine/pentium/decoder.m"
03628                                           
03629 
03630                                                 stmts = instantiate(pc,  "SHRD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
03631 
03632                                           
03633 
03634                                           
03635                                           
03636                                           
03637                                         }
03638                                         
03639                                       } /*opt-block*/
03640                                       else { 
03641                                         MATCH_w_8_32 = getByte(4 + MATCH_p); 
03642                                         goto MATCH_label_c903; 
03643                                         
03644                                       } /*opt-block*/
03645                                       
03646                                       break;
03647                                     case 2: 
03648                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03649                                       if ((MATCH_w_8_16 & 0x7) 
03650                                               /* r_m at 16 */ == 4 && 
03651                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03652                                               /* index at 24 */ && 
03653                                         (MATCH_w_8_24 >> 3 & 0x7) 
03654                                               /* index at 24 */ < 8)) { 
03655                                         MATCH_w_8_64 = getByte(8 + MATCH_p); 
03656                                         goto MATCH_label_c904; 
03657                                         
03658                                       } /*opt-block*/
03659                                       else { 
03660                                         MATCH_w_8_56 = getByte(7 + MATCH_p); 
03661                                         goto MATCH_label_c905; 
03662                                         
03663                                       } /*opt-block*/
03664                                       
03665                                       break;
03666                                     case 3: 
03667                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03668                                       goto MATCH_label_c902; 
03669                                       
03670                                       break;
03671                                     default: assert(0);
03672                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03673                                         -- mod at 16 --*/ 
03674                                 
03675                               } /*opt-block*/
03676                               else { 
03677                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03678                                 
03679                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03680                                         /* mod at 16 */) {
03681                                     case 0: 
03682                                       
03683                                         switch((MATCH_w_8_16 & 0x7) 
03684                                               /* r_m at 16 */) {
03685                                           case 0: case 1: case 2: case 3: 
03686                                           case 6: case 7: 
03687                                             MATCH_w_8_24 = 
03688                                               getByte(3 + MATCH_p); 
03689                                             goto MATCH_label_c898; 
03690                                             
03691                                             break;
03692                                           case 4: 
03693                                             MATCH_w_8_24 = 
03694                                               getByte(3 + MATCH_p); 
03695                                             if ((MATCH_w_8_24 & 0x7) 
03696                                                     /* base at 24 */ == 5 && 
03697                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03698                                                     /* index at 24 */ && 
03699                                               (MATCH_w_8_24 >> 3 & 0x7) 
03700                                                     /* index at 24 */ < 8)) { 
03701                                               MATCH_w_8_64 = 
03702                                                 getByte(8 + MATCH_p); 
03703                                               goto MATCH_label_c900; 
03704                                               
03705                                             } /*opt-block*/
03706                                             else { 
03707                                               MATCH_w_8_32 = 
03708                                                 getByte(4 + MATCH_p); 
03709                                               goto MATCH_label_c899; 
03710                                               
03711                                             } /*opt-block*/
03712                                             
03713                                             break;
03714                                           case 5: 
03715                                             MATCH_w_8_56 = 
03716                                               getByte(7 + MATCH_p); 
03717                                             goto MATCH_label_c901; 
03718                                             
03719                                             break;
03720                                           default: assert(0);
03721                                         } /* (MATCH_w_8_16 & 0x7) 
03722                                               -- r_m at 16 --*/ 
03723                                       break;
03724                                     case 1: 
03725                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03726                                       if ((MATCH_w_8_16 & 0x7) 
03727                                               /* r_m at 16 */ == 4 && 
03728                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03729                                               /* index at 24 */ && 
03730                                         (MATCH_w_8_24 >> 3 & 0x7) 
03731                                               /* index at 24 */ < 8)) { 
03732                                         MATCH_w_8_40 = getByte(5 + MATCH_p); 
03733                                         { 
03734                                           unsigned Eaddr = 
03735                                             2 + addressToPC(MATCH_p);
03736                                           unsigned count = 
03737                                             (MATCH_w_8_40 & 0xff) 
03738                                                   /* i8 at 40 */;
03739                                           unsigned reg = 
03740                                             (MATCH_w_8_16 >> 3 & 0x7) 
03741                                                   /* reg_opcode at 16 */;
03742                                           nextPC = 6 + MATCH_p; 
03743                                           
03744 #line 444 "frontend/machine/pentium/decoder.m"
03745                                           
03746 
03747                                                 stmts = instantiate(pc,  "SHLD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
03748 
03749                                           
03750 
03751                                           
03752                                           
03753                                           
03754                                         }
03755                                         
03756                                       } /*opt-block*/
03757                                       else { 
03758                                         MATCH_w_8_32 = getByte(4 + MATCH_p); 
03759                                         goto MATCH_label_c899; 
03760                                         
03761                                       } /*opt-block*/
03762                                       
03763                                       break;
03764                                     case 2: 
03765                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03766                                       if ((MATCH_w_8_16 & 0x7) 
03767                                               /* r_m at 16 */ == 4 && 
03768                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03769                                               /* index at 24 */ && 
03770                                         (MATCH_w_8_24 >> 3 & 0x7) 
03771                                               /* index at 24 */ < 8)) { 
03772                                         MATCH_w_8_64 = getByte(8 + MATCH_p); 
03773                                         goto MATCH_label_c900; 
03774                                         
03775                                       } /*opt-block*/
03776                                       else { 
03777                                         MATCH_w_8_56 = getByte(7 + MATCH_p); 
03778                                         goto MATCH_label_c901; 
03779                                         
03780                                       } /*opt-block*/
03781                                       
03782                                       break;
03783                                     case 3: 
03784                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03785                                       goto MATCH_label_c898; 
03786                                       
03787                                       break;
03788                                     default: assert(0);
03789                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03790                                         -- mod at 16 --*/ 
03791                                 
03792                               } /*opt-block*/
03793                               break;
03794                             case 5: 
03795                               if ((MATCH_w_8_8 >> 3 & 0x1) 
03796                                       /* page at 8 */ == 1) { 
03797                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03798                                 
03799                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03800                                         /* mod at 16 */) {
03801                                     case 0: 
03802                                       
03803                                         switch((MATCH_w_8_16 & 0x7) 
03804                                               /* r_m at 16 */) {
03805                                           case 0: case 1: case 2: case 3: 
03806                                           case 6: case 7: 
03807                                             goto MATCH_label_c910; break;
03808                                           case 4: 
03809                                             MATCH_w_8_24 = 
03810                                               getByte(3 + MATCH_p); 
03811                                             if ((MATCH_w_8_24 & 0x7) 
03812                                                     /* base at 24 */ == 5 && 
03813                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03814                                                     /* index at 24 */ && 
03815                                               (MATCH_w_8_24 >> 3 & 0x7) 
03816                                                     /* index at 24 */ < 8)) 
03817                                               goto MATCH_label_c912;  /*opt-block+*/
03818                                             else 
03819                                               goto MATCH_label_c911;  /*opt-block+*/
03820                                             
03821                                             break;
03822                                           case 5: 
03823                                             goto MATCH_label_c913; break;
03824                                           default: assert(0);
03825                                         } /* (MATCH_w_8_16 & 0x7) 
03826                                               -- r_m at 16 --*/ 
03827                                       break;
03828                                     case 1: 
03829                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03830                                       if ((MATCH_w_8_16 & 0x7) 
03831                                               /* r_m at 16 */ == 4 && 
03832                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03833                                               /* index at 24 */ && 
03834                                         (MATCH_w_8_24 >> 3 & 0x7) 
03835                                               /* index at 24 */ < 8)) { 
03836                                         unsigned Eaddr = 
03837                                           2 + addressToPC(MATCH_p);
03838                                         unsigned reg = 
03839                                           (MATCH_w_8_16 >> 3 & 0x7) 
03840                                                 /* reg_opcode at 16 */;
03841                                         nextPC = 5 + MATCH_p; 
03842                                         
03843 #line 438 "frontend/machine/pentium/decoder.m"
03844                                         
03845 
03846                                                 stmts = instantiate(pc,  "SHRD.CLod", DIS_EADDR32, DIS_REG32);
03847 
03848                                         
03849 
03850                                         
03851                                         
03852                                         
03853                                       } /*opt-block*//*opt-block+*/
03854                                       else 
03855                                         goto MATCH_label_c911;  /*opt-block+*/
03856                                       
03857                                       break;
03858                                     case 2: 
03859                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03860                                       if ((MATCH_w_8_16 & 0x7) 
03861                                               /* r_m at 16 */ == 4 && 
03862                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03863                                               /* index at 24 */ && 
03864                                         (MATCH_w_8_24 >> 3 & 0x7) 
03865                                               /* index at 24 */ < 8)) 
03866                                         goto MATCH_label_c912;  /*opt-block+*/
03867                                       else 
03868                                         goto MATCH_label_c913;  /*opt-block+*/
03869                                       
03870                                       break;
03871                                     case 3: 
03872                                       goto MATCH_label_c910; break;
03873                                     default: assert(0);
03874                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03875                                         -- mod at 16 --*/ 
03876                                 
03877                               } /*opt-block*/
03878                               else { 
03879                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03880                                 
03881                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03882                                         /* mod at 16 */) {
03883                                     case 0: 
03884                                       
03885                                         switch((MATCH_w_8_16 & 0x7) 
03886                                               /* r_m at 16 */) {
03887                                           case 0: case 1: case 2: case 3: 
03888                                           case 6: case 7: 
03889                                             goto MATCH_label_c906; break;
03890                                           case 4: 
03891                                             MATCH_w_8_24 = 
03892                                               getByte(3 + MATCH_p); 
03893                                             if ((MATCH_w_8_24 & 0x7) 
03894                                                     /* base at 24 */ == 5 && 
03895                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03896                                                     /* index at 24 */ && 
03897                                               (MATCH_w_8_24 >> 3 & 0x7) 
03898                                                     /* index at 24 */ < 8)) 
03899                                               goto MATCH_label_c908;  /*opt-block+*/
03900                                             else 
03901                                               goto MATCH_label_c907;  /*opt-block+*/
03902                                             
03903                                             break;
03904                                           case 5: 
03905                                             goto MATCH_label_c909; break;
03906                                           default: assert(0);
03907                                         } /* (MATCH_w_8_16 & 0x7) 
03908                                               -- r_m at 16 --*/ 
03909                                       break;
03910                                     case 1: 
03911                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03912                                       if ((MATCH_w_8_16 & 0x7) 
03913                                               /* r_m at 16 */ == 4 && 
03914                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03915                                               /* index at 24 */ && 
03916                                         (MATCH_w_8_24 >> 3 & 0x7) 
03917                                               /* index at 24 */ < 8)) { 
03918                                         unsigned Eaddr = 
03919                                           2 + addressToPC(MATCH_p);
03920                                         unsigned reg = 
03921                                           (MATCH_w_8_16 >> 3 & 0x7) 
03922                                                 /* reg_opcode at 16 */;
03923                                         nextPC = 5 + MATCH_p; 
03924                                         
03925 #line 432 "frontend/machine/pentium/decoder.m"
03926                                         
03927 
03928                                                 stmts = instantiate(pc,  "SHLD.CLod", DIS_EADDR32, DIS_REG32);
03929 
03930                                         
03931 
03932                                         
03933                                         
03934                                         
03935                                       } /*opt-block*//*opt-block+*/
03936                                       else 
03937                                         goto MATCH_label_c907;  /*opt-block+*/
03938                                       
03939                                       break;
03940                                     case 2: 
03941                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03942                                       if ((MATCH_w_8_16 & 0x7) 
03943                                               /* r_m at 16 */ == 4 && 
03944                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03945                                               /* index at 24 */ && 
03946                                         (MATCH_w_8_24 >> 3 & 0x7) 
03947                                               /* index at 24 */ < 8)) 
03948                                         goto MATCH_label_c908;  /*opt-block+*/
03949                                       else 
03950                                         goto MATCH_label_c909;  /*opt-block+*/
03951                                       
03952                                       break;
03953                                     case 3: 
03954                                       goto MATCH_label_c906; break;
03955                                     default: assert(0);
03956                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03957                                         -- mod at 16 --*/ 
03958                                 
03959                               } /*opt-block*/
03960                               break;
03961                             case 6: 
03962                               goto MATCH_label_c64; break;
03963                             case 7: 
03964                               if ((MATCH_w_8_8 >> 3 & 0x1) 
03965                                       /* page at 8 */ == 1) { 
03966                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03967                                 
03968                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03969                                         /* mod at 16 */) {
03970                                     case 0: 
03971                                       
03972                                         switch((MATCH_w_8_16 & 0x7) 
03973                                               /* r_m at 16 */) {
03974                                           case 0: case 1: case 2: case 3: 
03975                                           case 6: case 7: 
03976                                             goto MATCH_label_c914; break;
03977                                           case 4: 
03978                                             MATCH_w_8_24 = 
03979                                               getByte(3 + MATCH_p); 
03980                                             if ((MATCH_w_8_24 & 0x7) 
03981                                                     /* base at 24 */ == 5 && 
03982                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03983                                                     /* index at 24 */ && 
03984                                               (MATCH_w_8_24 >> 3 & 0x7) 
03985                                                     /* index at 24 */ < 8)) 
03986                                               goto MATCH_label_c916;  /*opt-block+*/
03987                                             else 
03988                                               goto MATCH_label_c915;  /*opt-block+*/
03989                                             
03990                                             break;
03991                                           case 5: 
03992                                             goto MATCH_label_c917; break;
03993                                           default: assert(0);
03994                                         } /* (MATCH_w_8_16 & 0x7) 
03995                                               -- r_m at 16 --*/ 
03996                                       break;
03997                                     case 1: 
03998                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03999                                       if ((MATCH_w_8_16 & 0x7) 
04000                                               /* r_m at 16 */ == 4 && 
04001                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04002                                               /* index at 24 */ && 
04003                                         (MATCH_w_8_24 >> 3 & 0x7) 
04004                                               /* index at 24 */ < 8)) { 
04005                                         unsigned Eaddr = 
04006                                           2 + addressToPC(MATCH_p);
04007                                         unsigned reg = 
04008                                           (MATCH_w_8_16 >> 3 & 0x7) 
04009                                                 /* reg_opcode at 16 */;
04010                                         nextPC = 5 + MATCH_p; 
04011                                         
04012 #line 1166 "frontend/machine/pentium/decoder.m"
04013                                         
04014 
04015                                                 stmts = instantiate(pc,  "IMULrmod", DIS_REG32, DIS_EADDR32);
04016 
04017                                         
04018 
04019                                         
04020                                         
04021                                         
04022                                       } /*opt-block*//*opt-block+*/
04023                                       else 
04024                                         goto MATCH_label_c915;  /*opt-block+*/
04025                                       
04026                                       break;
04027                                     case 2: 
04028                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
04029                                       if ((MATCH_w_8_16 & 0x7) 
04030                                               /* r_m at 16 */ == 4 && 
04031                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04032                                               /* index at 24 */ && 
04033                                         (MATCH_w_8_24 >> 3 & 0x7) 
04034                                               /* index at 24 */ < 8)) 
04035                                         goto MATCH_label_c916;  /*opt-block+*/
04036                                       else 
04037                                         goto MATCH_label_c917;  /*opt-block+*/
04038                                       
04039                                       break;
04040                                     case 3: 
04041                                       goto MATCH_label_c914; break;
04042                                     default: assert(0);
04043                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
04044                                         -- mod at 16 --*/ 
04045                                 
04046                               } /*opt-block*/
04047                               else 
04048                                 goto MATCH_label_c64;  /*opt-block+*/
04049                               break;
04050                             default: assert(0);
04051                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
04052                         break;
04053                       case 11: 
04054                         if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) 
04055                           
04056                             switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
04057                               case 0: case 1: 
04058                                 goto MATCH_label_c64; break;
04059                               case 2: 
04060                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
04061                                 
04062                                   switch((MATCH_w_8_16 >> 3 & 0x7) 
04063                                         /* reg_opcode at 16 */) {
04064                                     case 0: case 1: case 2: case 3: 
04065                                       goto MATCH_label_c64; break;
04066                                     case 4: 
04067                                       
04068                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
04069                                               /* mod at 16 */) {
04070                                           case 0: 
04071                                             
04072                                               switch((MATCH_w_8_16 & 0x7) 
04073                                                     /* r_m at 16 */) {
04074                                                 case 0: case 1: case 2: 
04075                                                 case 3: case 6: case 7: 
04076                                                   MATCH_w_8_24 = 
04077                                                     getByte(3 + MATCH_p); 
04078                                                   goto MATCH_label_c947; 
04079                                                   
04080                                                   break;
04081                                                 case 4: 
04082                                                   MATCH_w_8_24 = 
04083                                                     getByte(3 + MATCH_p); 
04084                                                   if ((MATCH_w_8_24 & 0x7) 
04085                                                           /* base at 24 */ == 5 && 
04086                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04087                                                           /* index at 24 */ && 
04088                                                     (MATCH_w_8_24 >> 3 & 0x7) 
04089                                                           /* index at 24 */ < 8)) { 
04090                                                     MATCH_w_8_64 = 
04091                                                       getByte(8 + MATCH_p); 
04092                                                     goto MATCH_label_c949; 
04093                                                     
04094                                                   } /*opt-block*/
04095                                                   else { 
04096                                                     MATCH_w_8_32 = 
04097                                                       getByte(4 + MATCH_p); 
04098                                                     goto MATCH_label_c948; 
04099                                                     
04100                                                   } /*opt-block*/
04101                                                   
04102                                                   break;
04103                                                 case 5: 
04104                                                   MATCH_w_8_56 = 
04105                                                     getByte(7 + MATCH_p); 
04106                                                   goto MATCH_label_c950; 
04107                                                   
04108                                                   break;
04109                                                 default: assert(0);
04110                                               } /* (MATCH_w_8_16 & 0x7) 
04111                                                     -- r_m at 16 --*/ 
04112                                             break;
04113                                           case 1: 
04114                                             MATCH_w_8_24 = 
04115                                               getByte(3 + MATCH_p); 
04116                                             if ((MATCH_w_8_16 & 0x7) 
04117                                                     /* r_m at 16 */ == 4 && 
04118                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04119                                                     /* index at 24 */ && 
04120                                               (MATCH_w_8_24 >> 3 & 0x7) 
04121                                                     /* index at 24 */ < 8)) { 
04122                                               MATCH_w_8_40 = 
04123                                                 getByte(5 + MATCH_p); 
04124                                               { 
04125                                                 unsigned Eaddr = 
04126                                                   2 + addressToPC(MATCH_p);
04127                                                 int /* [~128..127] */ i8 = 
04128                                                   sign_extend((MATCH_w_8_40 & 0xff) 
04129                                                                     /* i8 at 40 */, 
04130                                                               8);
04131                                                 nextPC = 6 + MATCH_p; 
04132                                                 
04133 #line 1346 "frontend/machine/pentium/decoder.m"
04134                                                 
04135 
04136                                                         stmts = instantiate(pc,  "BTiod", DIS_EADDR32, DIS_I8);
04137 
04138                                                 
04139 
04140                                                 
04141                                                 
04142                                                 
04143                                               }
04144                                               
04145                                             } /*opt-block*/
04146                                             else { 
04147                                               MATCH_w_8_32 = 
04148                                                 getByte(4 + MATCH_p); 
04149                                               goto MATCH_label_c948; 
04150                                               
04151                                             } /*opt-block*/
04152                                             
04153                                             break;
04154                                           case 2: 
04155                                             MATCH_w_8_24 = 
04156                                               getByte(3 + MATCH_p); 
04157                                             if ((MATCH_w_8_16 & 0x7) 
04158                                                     /* r_m at 16 */ == 4 && 
04159                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04160                                                     /* index at 24 */ && 
04161                                               (MATCH_w_8_24 >> 3 & 0x7) 
04162                                                     /* index at 24 */ < 8)) { 
04163                                               MATCH_w_8_64 = 
04164                                                 getByte(8 + MATCH_p); 
04165                                               goto MATCH_label_c949; 
04166                                               
04167                                             } /*opt-block*/
04168                                             else { 
04169                                               MATCH_w_8_56 = 
04170                                                 getByte(7 + MATCH_p); 
04171                                               goto MATCH_label_c950; 
04172                                               
04173                                             } /*opt-block*/
04174                                             
04175                                             break;
04176                                           case 3: 
04177                                             MATCH_w_8_24 = 
04178                                               getByte(3 + MATCH_p); 
04179                                             goto MATCH_label_c947; 
04180                                             
04181                                             break;
04182                                           default: assert(0);
04183                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
04184                                               -- mod at 16 --*/ 
04185                                       break;
04186                                     case 5: 
04187                                       
04188                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
04189                                               /* mod at 16 */) {
04190                                           case 0: 
04191                                             
04192                                               switch((MATCH_w_8_16 & 0x7) 
04193                                                     /* r_m at 16 */) {
04194                                                 case 0: case 1: case 2: 
04195                                                 case 3: case 6: case 7: 
04196                                                   MATCH_w_8_24 = 
04197                                                     getByte(3 + MATCH_p); 
04198                                                   goto MATCH_label_c951; 
04199                                                   
04200                                                   break;
04201                                                 case 4: 
04202                                                   MATCH_w_8_24 = 
04203                                                     getByte(3 + MATCH_p); 
04204                                                   if ((MATCH_w_8_24 & 0x7) 
04205                                                           /* base at 24 */ == 5 && 
04206                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04207                                                           /* index at 24 */ && 
04208                                                     (MATCH_w_8_24 >> 3 & 0x7) 
04209                                                           /* index at 24 */ < 8)) { 
04210                                                     MATCH_w_8_64 = 
04211                                                       getByte(8 + MATCH_p); 
04212                                                     goto MATCH_label_c953; 
04213                                                     
04214                                                   } /*opt-block*/
04215                                                   else { 
04216                                                     MATCH_w_8_32 = 
04217                                                       getByte(4 + MATCH_p); 
04218                                                     goto MATCH_label_c952; 
04219                                                     
04220                                                   } /*opt-block*/
04221                                                   
04222                                                   break;
04223                                                 case 5: 
04224                                                   MATCH_w_8_56 = 
04225                                                     getByte(7 + MATCH_p); 
04226                                                   goto MATCH_label_c954; 
04227                                                   
04228                                                   break;
04229                                                 default: assert(0);
04230                                               } /* (MATCH_w_8_16 & 0x7) 
04231                                                     -- r_m at 16 --*/ 
04232                                             break;
04233                                           case 1: 
04234                                             MATCH_w_8_24 = 
04235                                               getByte(3 + MATCH_p); 
04236                                             if ((MATCH_w_8_16 & 0x7) 
04237                                                     /* r_m at 16 */ == 4 && 
04238                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04239                                                     /* index at 24 */ && 
04240                                               (MATCH_w_8_24 >> 3 & 0x7) 
04241                                                     /* index at 24 */ < 8)) { 
04242                                               MATCH_w_8_40 = 
04243                                                 getByte(5 + MATCH_p); 
04244                                               { 
04245                                                 unsigned Eaddr = 
04246                                                   2 + addressToPC(MATCH_p);
04247                                                 int /* [~128..127] */ i8 = 
04248                                                   sign_extend((MATCH_w_8_40 & 0xff) 
04249                                                                     /* i8 at 40 */, 
04250                                                               8);
04251                                                 nextPC = 6 + MATCH_p; 
04252                                                 
04253 #line 1310 "frontend/machine/pentium/decoder.m"
04254                                                 
04255 
04256                                                         stmts = instantiate(pc,  "BTSiod", DIS_I8, DIS_EADDR32);
04257 
04258                                                 
04259 
04260                                                 
04261                                                 
04262                                                 
04263                                               }
04264                                               
04265                                             } /*opt-block*/
04266                                             else { 
04267                                               MATCH_w_8_32 = 
04268                                                 getByte(4 + MATCH_p); 
04269                                               goto MATCH_label_c952; 
04270                                               
04271                                             } /*opt-block*/
04272                                             
04273                                             break;
04274                                           case 2: 
04275                                             MATCH_w_8_24 = 
04276                                               getByte(3 + MATCH_p); 
04277                                             if ((MATCH_w_8_16 & 0x7) 
04278                                                     /* r_m at 16 */ == 4 && 
04279                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04280                                                     /* index at 24 */ && 
04281                                               (MATCH_w_8_24 >> 3 & 0x7) 
04282                                                     /* index at 24 */ < 8)) { 
04283                                               MATCH_w_8_64 = 
04284                                                 getByte(8 + MATCH_p); 
04285                                               goto MATCH_label_c953; 
04286                                               
04287                                             } /*opt-block*/
04288                                             else { 
04289                                               MATCH_w_8_56 = 
04290                                                 getByte(7 + MATCH_p); 
04291                                               goto MATCH_label_c954; 
04292                                               
04293                                             } /*opt-block*/
04294                                             
04295                                             break;
04296                                           case 3: 
04297                                             MATCH_w_8_24 = 
04298                                               getByte(3 + MATCH_p); 
04299                                             goto MATCH_label_c951; 
04300                                             
04301                                             break;
04302                                           default: assert(0);
04303                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
04304                                               -- mod at 16 --*/ 
04305                                       break;
04306                                     case 6: 
04307                                       
04308                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
04309                                               /* mod at 16 */) {
04310                                           case 0: 
04311                                             
04312                                               switch((MATCH_w_8_16 & 0x7) 
04313                                                     /* r_m at 16 */) {
04314                                                 case 0: case 1: case 2: 
04315                                                 case 3: case 6: case 7: 
04316                                                   MATCH_w_8_24 = 
04317                                                     getByte(3 + MATCH_p); 
04318                                                   goto MATCH_label_c955; 
04319                                                   
04320                                                   break;
04321                                                 case 4: 
04322                                                   MATCH_w_8_24 = 
04323                                                     getByte(3 + MATCH_p); 
04324                                                   if ((MATCH_w_8_24 & 0x7) 
04325                                                           /* base at 24 */ == 5 && 
04326                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04327                                                           /* index at 24 */ && 
04328                                                     (MATCH_w_8_24 >> 3 & 0x7) 
04329                                                           /* index at 24 */ < 8)) { 
04330                                                     MATCH_w_8_64 = 
04331                                                       getByte(8 + MATCH_p); 
04332                                                     goto MATCH_label_c957; 
04333                                                     
04334                                                   } /*opt-block*/
04335                                                   else { 
04336                                                     MATCH_w_8_32 = 
04337                                                       getByte(4 + MATCH_p); 
04338                                                     goto MATCH_label_c956; 
04339                                                     
04340                                                   } /*opt-block*/
04341                                                   
04342                                                   break;
04343                                                 case 5: 
04344                                                   MATCH_w_8_56 = 
04345                                                     getByte(7 + MATCH_p); 
04346                                                   goto MATCH_label_c958; 
04347                                                   
04348                                                   break;
04349                                                 default: assert(0);
04350                                               } /* (MATCH_w_8_16 & 0x7) 
04351                                                     -- r_m at 16 --*/ 
04352                                             break;
04353                                           case 1: 
04354                                             MATCH_w_8_24 = 
04355                                               getByte(3 + MATCH_p); 
04356                                             if ((MATCH_w_8_16 & 0x7) 
04357                                                     /* r_m at 16 */ == 4 && 
04358                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04359                                                     /* index at 24 */ && 
04360                                               (MATCH_w_8_24 >> 3 & 0x7) 
04361                                                     /* index at 24 */ < 8)) { 
04362                                               MATCH_w_8_40 = 
04363                                                 getByte(5 + MATCH_p); 
04364                                               { 
04365                                                 unsigned Eaddr = 
04366                                                   2 + addressToPC(MATCH_p);
04367                                                 int /* [~128..127] */ i8 = 
04368                                                   sign_extend((MATCH_w_8_40 & 0xff) 
04369                                                                     /* i8 at 40 */, 
04370                                                               8);
04371                                                 nextPC = 6 + MATCH_p; 
04372                                                 
04373 #line 1322 "frontend/machine/pentium/decoder.m"
04374                                                 
04375 
04376                                                         stmts = instantiate(pc,  "BTRiod", DIS_EADDR32, DIS_I8);
04377 
04378                                                 
04379 
04380                                                 
04381                                                 
04382                                                 
04383                                               }
04384                                               
04385                                             } /*opt-block*/
04386                                             else { 
04387                                               MATCH_w_8_32 = 
04388                                                 getByte(4 + MATCH_p); 
04389                                               goto MATCH_label_c956; 
04390                                               
04391                                             } /*opt-block*/
04392                                             
04393                                             break;
04394                                           case 2: 
04395                                             MATCH_w_8_24 = 
04396                                               getByte(3 + MATCH_p); 
04397                                             if ((MATCH_w_8_16 & 0x7) 
04398                                                     /* r_m at 16 */ == 4 && 
04399                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04400                                                     /* index at 24 */ && 
04401                                               (MATCH_w_8_24 >> 3 & 0x7) 
04402                                                     /* index at 24 */ < 8)) { 
04403                                               MATCH_w_8_64 = 
04404                                                 getByte(8 + MATCH_p); 
04405                                               goto MATCH_label_c957; 
04406                                               
04407                                             } /*opt-block*/
04408                                             else { 
04409                                               MATCH_w_8_56 = 
04410                                                 getByte(7 + MATCH_p); 
04411                                               goto MATCH_label_c958; 
04412                                               
04413                                             } /*opt-block*/
04414                                             
04415                                             break;
04416                                           case 3: 
04417                                             MATCH_w_8_24 = 
04418                                               getByte(3 + MATCH_p); 
04419                                             goto MATCH_label_c955; 
04420                                             
04421                                             break;
04422                                           default: assert(0);
04423                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
04424                                               -- mod at 16 --*/ 
04425                                       break;
04426                                     case 7: 
04427                                       
04428                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
04429                                               /* mod at 16 */) {
04430                                           case 0: 
04431                                             
04432                                               switch((MATCH_w_8_16 & 0x7) 
04433                                                     /* r_m at 16 */) {
04434                                                 case 0: case 1: case 2: 
04435                                                 case 3: case 6: case 7: 
04436                                                   MATCH_w_8_24 = 
04437                                                     getByte(3 + MATCH_p); 
04438                                                   goto MATCH_label_c959; 
04439                                                   
04440                                                   break;
04441                                                 case 4: 
04442                                                   MATCH_w_8_24 = 
04443                                                     getByte(3 + MATCH_p); 
04444                                                   if ((MATCH_w_8_24 & 0x7) 
04445                                                           /* base at 24 */ == 5 && 
04446                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04447                                                           /* index at 24 */ && 
04448                                                     (MATCH_w_8_24 >> 3 & 0x7) 
04449                                                           /* index at 24 */ < 8)) { 
04450                                                     MATCH_w_8_64 = 
04451                                                       getByte(8 + MATCH_p); 
04452                                                     goto MATCH_label_c961; 
04453                                                     
04454                                                   } /*opt-block*/
04455                                                   else { 
04456                                                     MATCH_w_8_32 = 
04457                                                       getByte(4 + MATCH_p); 
04458                                                     goto MATCH_label_c960; 
04459                                                     
04460                                                   } /*opt-block*/
04461                                                   
04462                                                   break;
04463                                                 case 5: 
04464                                                   MATCH_w_8_56 = 
04465                                                     getByte(7 + MATCH_p); 
04466                                                   goto MATCH_label_c962; 
04467                                                   
04468                                                   break;
04469                                                 default: assert(0);
04470                                               } /* (MATCH_w_8_16 & 0x7) 
04471                                                     -- r_m at 16 --*/ 
04472                                             break;
04473                                           case 1: 
04474                                             MATCH_w_8_24 = 
04475                                               getByte(3 + MATCH_p); 
04476                                             if ((MATCH_w_8_16 & 0x7) 
04477                                                     /* r_m at 16 */ == 4 && 
04478                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04479                                                     /* index at 24 */ && 
04480                                               (MATCH_w_8_24 >> 3 & 0x7) 
04481                                                     /* index at 24 */ < 8)) { 
04482                                               MATCH_w_8_40 = 
04483                                                 getByte(5 + MATCH_p); 
04484                                               { 
04485                                                 unsigned Eaddr = 
04486                                                   2 + addressToPC(MATCH_p);
04487                                                 int /* [~128..127] */ i8 = 
04488                                                   sign_extend((MATCH_w_8_40 & 0xff) 
04489                                                                     /* i8 at 40 */, 
04490                                                               8);
04491                                                 nextPC = 6 + MATCH_p; 
04492                                                 
04493 #line 1334 "frontend/machine/pentium/decoder.m"
04494                                                 
04495 
04496                                                         stmts = instantiate(pc,  "BTCiod", DIS_EADDR32, DIS_I8);
04497 
04498                                                 
04499 
04500                                                 
04501                                                 
04502                                                 
04503                                               }
04504                                               
04505                                             } /*opt-block*/
04506                                             else { 
04507                                               MATCH_w_8_32 = 
04508                                                 getByte(4 + MATCH_p); 
04509                                               goto MATCH_label_c960; 
04510                                               
04511                                             } /*opt-block*/
04512                                             
04513                                             break;
04514                                           case 2: 
04515                                             MATCH_w_8_24 = 
04516                                               getByte(3 + MATCH_p); 
04517                                             if ((MATCH_w_8_16 & 0x7) 
04518                                                     /* r_m at 16 */ == 4 && 
04519                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04520                                                     /* index at 24 */ && 
04521                                               (MATCH_w_8_24 >> 3 & 0x7) 
04522                                                     /* index at 24 */ < 8)) { 
04523                                               MATCH_w_8_64 = 
04524                                                 getByte(8 + MATCH_p); 
04525                                               goto MATCH_label_c961; 
04526                                               
04527                                             } /*opt-block*/
04528                                             else { 
04529                                               MATCH_w_8_56 = 
04530                                                 getByte(7 + MATCH_p); 
04531                                               goto MATCH_label_c962; 
04532                                               
04533                                             } /*opt-block*/
04534                                             
04535                                             break;
04536                                           case 3: 
04537                                             MATCH_w_8_24 = 
04538                                               getByte(3 + MATCH_p); 
04539                                             goto MATCH_label_c959; 
04540                                             
04541                                             break;
04542                                           default: assert(0);
04543                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
04544                                               -- mod at 16 --*/ 
04545                                       break;
04546                                     default: assert(0);
04547                                   } /* (MATCH_w_8_16 >> 3 & 0x7) 
04548                                         -- reg_opcode at 16 --*/ 
04549                                 
04550                                 break;
04551                               case 3: 
04552                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
04553                                 
04554                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
04555                                         /* mod at 16 */) {
04556                                     case 0: 
04557                                       
04558                                         switch((MATCH_w_8_16 & 0x7) 
04559                                               /* r_m at 16 */) {
04560                                           case 0: case 1: case 2: case 3: 
04561                                           case 6: case 7: 
04562                                             goto MATCH_label_c963; break;
04563                                           case 4: 
04564                                             MATCH_w_8_24 = 
04565                                               getByte(3 + MATCH_p); 
04566                                             if ((MATCH_w_8_24 & 0x7) 
04567                                                     /* base at 24 */ == 5 && 
04568                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04569                                                     /* index at 24 */ && 
04570                                               (MATCH_w_8_24 >> 3 & 0x7) 
04571                                                     /* index at 24 */ < 8)) 
04572                                               goto MATCH_label_c965;  /*opt-block+*/
04573                                             else 
04574                                               goto MATCH_label_c964;  /*opt-block+*/
04575                                             
04576                                             break;
04577                                           case 5: 
04578                                             goto MATCH_label_c966; break;
04579                                           default: assert(0);
04580                                         } /* (MATCH_w_8_16 & 0x7) 
04581                                               -- r_m at 16 --*/ 
04582                                       break;
04583                                     case 1: 
04584                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
04585                                       if ((MATCH_w_8_16 & 0x7) 
04586                                               /* r_m at 16 */ == 4 && 
04587                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04588                                               /* index at 24 */ && 
04589                                         (MATCH_w_8_24 >> 3 & 0x7) 
04590                                               /* index at 24 */ < 8)) { 
04591                                         unsigned Eaddr = 
04592                                           2 + addressToPC(MATCH_p);
04593                                         unsigned reg = 
04594                                           (MATCH_w_8_16 >> 3 & 0x7) 
04595                                                 /* reg_opcode at 16 */;
04596                                         nextPC = 5 + MATCH_p; 
04597                                         
04598 #line 1340 "frontend/machine/pentium/decoder.m"
04599                                         
04600 
04601                                                 stmts = instantiate(pc,  "BTCod", DIS_EADDR32, DIS_REG32);
04602 
04603                                         
04604 
04605                                         
04606                                         
04607                                         
04608                                       } /*opt-block*//*opt-block+*/
04609                                       else 
04610                                         goto MATCH_label_c964;  /*opt-block+*/
04611                                       
04612                                       break;
04613                                     case 2: 
04614                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
04615                                       if ((MATCH_w_8_16 & 0x7) 
04616                                               /* r_m at 16 */ == 4 && 
04617                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04618                                               /* index at 24 */ && 
04619                                         (MATCH_w_8_24 >> 3 & 0x7) 
04620                                               /* index at 24 */ < 8)) 
04621                                         goto MATCH_label_c965;  /*opt-block+*/
04622                                       else 
04623                                         goto MATCH_label_c966;  /*opt-block+*/
04624                                       
04625                                       break;
04626                                     case 3: 
04627                                       goto MATCH_label_c963; break;
04628                                     default: assert(0);
04629                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
04630                                         -- mod at 16 --*/ 
04631                                 
04632                                 break;
04633                               case 4: 
04634                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
04635                                 
04636                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
04637                                         /* mod at 16 */) {
04638                                     case 0: 
04639                                       
04640                                         switch((MATCH_w_8_16 & 0x7) 
04641                                               /* r_m at 16 */) {
04642                                           case 0: case 1: case 2: case 3: 
04643                                           case 6: case 7: 
04644                                             goto MATCH_label_c967; break;
04645                                           case 4: 
04646                                             MATCH_w_8_24 = 
04647                                               getByte(3 + MATCH_p); 
04648                                             if ((MATCH_w_8_24 & 0x7) 
04649                                                     /* base at 24 */ == 5 && 
04650                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04651                                                     /* index at 24 */ && 
04652                                               (MATCH_w_8_24 >> 3 & 0x7) 
04653                                                     /* index at 24 */ < 8)) 
04654                                               goto MATCH_label_c969;  /*opt-block+*/
04655                                             else 
04656                                               goto MATCH_label_c968;  /*opt-block+*/
04657                                             
04658                                             break;
04659                                           case 5: 
04660                                             goto MATCH_label_c970; break;
04661                                           default: assert(0);
04662                                         } /* (MATCH_w_8_16 & 0x7) 
04663                                               -- r_m at 16 --*/ 
04664                                       break;
04665                                     case 1: 
04666                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
04667                                       if ((MATCH_w_8_16 & 0x7) 
04668                                               /* r_m at 16 */ == 4 && 
04669                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04670                                               /* index at 24 */ && 
04671                                         (MATCH_w_8_24 >> 3 & 0x7) 
04672                                               /* index at 24 */ < 8)) { 
04673                                         unsigned Eaddr = 
04674                                           2 + addressToPC(MATCH_p);
04675                                         unsigned reg = 
04676                                           (MATCH_w_8_16 >> 3 & 0x7) 
04677                                                 /* reg_opcode at 16 */;
04678                                         nextPC = 5 + MATCH_p; 
04679                                         
04680 #line 1372 "frontend/machine/pentium/decoder.m"
04681                                         
04682 
04683                                                 //stmts = instantiate(pc,  "BSFod", DIS_REG32, DIS_EADDR32);
04684 
04685                                                 genBSFR(pc, DIS_REG32, DIS_EADDR32, -1, 32, opPlus, nextPC-hostPC);
04686 
04687                                                 return result;
04688 
04689                                         
04690 
04691                                         
04692                                         
04693                                         
04694                                       } /*opt-block*//*opt-block+*/
04695                                       else 
04696                                         goto MATCH_label_c968;  /*opt-block+*/
04697                                       
04698                                       break;
04699                                     case 2: 
04700                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
04701                                       if ((MATCH_w_8_16 & 0x7) 
04702                                               /* r_m at 16 */ == 4 && 
04703                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04704                                               /* index at 24 */ && 
04705                                         (MATCH_w_8_24 >> 3 & 0x7) 
04706                                               /* index at 24 */ < 8)) 
04707                                         goto MATCH_label_c969;  /*opt-block+*/
04708                                       else 
04709                                         goto MATCH_label_c970;  /*opt-block+*/
04710                                       
04711                                       break;
04712                                     case 3: 
04713                                       goto MATCH_label_c967; break;
04714                                     default: assert(0);
04715                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
04716                                         -- mod at 16 --*/ 
04717                                 
04718                                 break;
04719                               case 5: 
04720                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
04721                                 
04722                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
04723                                         /* mod at 16 */) {
04724                                     case 0: 
04725                                       
04726                                         switch((MATCH_w_8_16 & 0x7) 
04727                                               /* r_m at 16 */) {
04728                                           case 0: case 1: case 2: case 3: 
04729                                           case 6: case 7: 
04730                                             goto MATCH_label_c971; break;
04731                                           case 4: 
04732                                             MATCH_w_8_24 = 
04733                                               getByte(3 + MATCH_p); 
04734                                             if ((MATCH_w_8_24 & 0x7) 
04735                                                     /* base at 24 */ == 5 && 
04736                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04737                                                     /* index at 24 */ && 
04738                                               (MATCH_w_8_24 >> 3 & 0x7) 
04739                                                     /* index at 24 */ < 8)) 
04740                                               goto MATCH_label_c973;  /*opt-block+*/
04741                                             else 
04742                                               goto MATCH_label_c972;  /*opt-block+*/
04743                                             
04744                                             break;
04745                                           case 5: 
04746                                             goto MATCH_label_c974; break;
04747                                           default: assert(0);
04748                                         } /* (MATCH_w_8_16 & 0x7) 
04749                                               -- r_m at 16 --*/ 
04750                                       break;
04751                                     case 1: 
04752                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
04753                                       if ((MATCH_w_8_16 & 0x7) 
04754                                               /* r_m at 16 */ == 4 && 
04755                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04756                                               /* index at 24 */ && 
04757                                         (MATCH_w_8_24 >> 3 & 0x7) 
04758                                               /* index at 24 */ < 8)) { 
04759                                         unsigned Eaddr = 
04760                                           2 + addressToPC(MATCH_p);
04761                                         unsigned reg = 
04762                                           (MATCH_w_8_16 >> 3 & 0x7) 
04763                                                 /* reg_opcode at 16 */;
04764                                         nextPC = 5 + MATCH_p; 
04765                                         
04766 #line 1361 "frontend/machine/pentium/decoder.m"
04767                                         
04768 
04769                                                 //stmts = instantiate(pc,  "BSRod", DIS_REG32, DIS_EADDR32);
04770 
04771                                                 // Bit Scan Forward: need helper function
04772 
04773                                                 genBSFR(pc, DIS_REG32, DIS_EADDR32, 32, 32, opMinus, nextPC-hostPC);
04774 
04775                                                 return result;
04776 
04777                                         
04778 
04779                                         
04780                                         
04781                                         
04782                                       } /*opt-block*//*opt-block+*/
04783                                       else 
04784                                         goto MATCH_label_c972;  /*opt-block+*/
04785                                       
04786                                       break;
04787                                     case 2: 
04788                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
04789                                       if ((MATCH_w_8_16 & 0x7) 
04790                                               /* r_m at 16 */ == 4 && 
04791                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04792                                               /* index at 24 */ && 
04793                                         (MATCH_w_8_24 >> 3 & 0x7) 
04794                                               /* index at 24 */ < 8)) 
04795                                         goto MATCH_label_c973;  /*opt-block+*/
04796                                       else 
04797                                         goto MATCH_label_c974;  /*opt-block+*/
04798                                       
04799                                       break;
04800                                     case 3: 
04801                                       goto MATCH_label_c971; break;
04802                                     default: assert(0);
04803                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
04804                                         -- mod at 16 --*/ 
04805                                 
04806                                 break;
04807                               case 6: 
04808                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
04809                                 
04810                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
04811                                         /* mod at 16 */) {
04812                                     case 0: 
04813                                       
04814                                         switch((MATCH_w_8_16 & 0x7) 
04815                                               /* r_m at 16 */) {
04816                                           case 0: case 1: case 2: case 3: 
04817                                           case 6: case 7: 
04818                                             goto MATCH_label_c975; break;
04819                                           case 4: 
04820                                             MATCH_w_8_24 = 
04821                                               getByte(3 + MATCH_p); 
04822                                             if ((MATCH_w_8_24 & 0x7) 
04823                                                     /* base at 24 */ == 5 && 
04824                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04825                                                     /* index at 24 */ && 
04826                                               (MATCH_w_8_24 >> 3 & 0x7) 
04827                                                     /* index at 24 */ < 8)) 
04828                                               goto MATCH_label_c977;  /*opt-block+*/
04829                                             else 
04830                                               goto MATCH_label_c976;  /*opt-block+*/
04831                                             
04832                                             break;
04833                                           case 5: 
04834                                             goto MATCH_label_c978; break;
04835                                           default: assert(0);
04836                                         } /* (MATCH_w_8_16 & 0x7) 
04837                                               -- r_m at 16 --*/ 
04838                                       break;
04839                                     case 1: 
04840                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
04841                                       if ((MATCH_w_8_16 & 0x7) 
04842                                               /* r_m at 16 */ == 4 && 
04843                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04844                                               /* index at 24 */ && 
04845                                         (MATCH_w_8_24 >> 3 & 0x7) 
04846                                               /* index at 24 */ < 8)) { 
04847                                         unsigned Eaddr = 
04848                                           2 + addressToPC(MATCH_p);
04849                                         unsigned r32 = 
04850                                           (MATCH_w_8_16 >> 3 & 0x7) 
04851                                                 /* reg_opcode at 16 */;
04852                                         nextPC = 5 + MATCH_p; 
04853                                         
04854 #line 949 "frontend/machine/pentium/decoder.m"
04855                                         
04856 
04857                                                 stmts = instantiate(pc,  "MOVSX.Gv.Ebod", DIS_R32, DIS_EADDR8);
04858 
04859                                         
04860 
04861                                         
04862                                         
04863                                         
04864                                       } /*opt-block*//*opt-block+*/
04865                                       else 
04866                                         goto MATCH_label_c976;  /*opt-block+*/
04867                                       
04868                                       break;
04869                                     case 2: 
04870                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
04871                                       if ((MATCH_w_8_16 & 0x7) 
04872                                               /* r_m at 16 */ == 4 && 
04873                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04874                                               /* index at 24 */ && 
04875                                         (MATCH_w_8_24 >> 3 & 0x7) 
04876                                               /* index at 24 */ < 8)) 
04877                                         goto MATCH_label_c977;  /*opt-block+*/
04878                                       else 
04879                                         goto MATCH_label_c978;  /*opt-block+*/
04880                                       
04881                                       break;
04882                                     case 3: 
04883                                       goto MATCH_label_c975; break;
04884                                     default: assert(0);
04885                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
04886                                         -- mod at 16 --*/ 
04887                                 
04888                                 break;
04889                               case 7: 
04890                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
04891                                 
04892                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
04893                                         /* mod at 16 */) {
04894                                     case 0: 
04895                                       
04896                                         switch((MATCH_w_8_16 & 0x7) 
04897                                               /* r_m at 16 */) {
04898                                           case 0: case 1: case 2: case 3: 
04899                                           case 6: case 7: 
04900                                             goto MATCH_label_c979; break;
04901                                           case 4: 
04902                                             MATCH_w_8_24 = 
04903                                               getByte(3 + MATCH_p); 
04904                                             if ((MATCH_w_8_24 & 0x7) 
04905                                                     /* base at 24 */ == 5 && 
04906                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04907                                                     /* index at 24 */ && 
04908                                               (MATCH_w_8_24 >> 3 & 0x7) 
04909                                                     /* index at 24 */ < 8)) 
04910                                               goto MATCH_label_c981;  /*opt-block+*/
04911                                             else 
04912                                               goto MATCH_label_c980;  /*opt-block+*/
04913                                             
04914                                             break;
04915                                           case 5: 
04916                                             goto MATCH_label_c982; break;
04917                                           default: assert(0);
04918                                         } /* (MATCH_w_8_16 & 0x7) 
04919                                               -- r_m at 16 --*/ 
04920                                       break;
04921                                     case 1: 
04922                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
04923                                       if ((MATCH_w_8_16 & 0x7) 
04924                                               /* r_m at 16 */ == 4 && 
04925                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04926                                               /* index at 24 */ && 
04927                                         (MATCH_w_8_24 >> 3 & 0x7) 
04928                                               /* index at 24 */ < 8)) { 
04929                                         unsigned Eaddr = 
04930                                           2 + addressToPC(MATCH_p);
04931                                         unsigned r32 = 
04932                                           (MATCH_w_8_16 >> 3 & 0x7) 
04933                                                 /* reg_opcode at 16 */;
04934                                         nextPC = 5 + MATCH_p; 
04935                                         
04936 #line 946 "frontend/machine/pentium/decoder.m"
04937                                         
04938 
04939                                                 stmts = instantiate(pc,  "MOVSX.Gv.Ew", DIS_R32, DIS_EADDR16);
04940 
04941                                         
04942 
04943                                         
04944                                         
04945                                         
04946                                       } /*opt-block*//*opt-block+*/
04947                                       else 
04948                                         goto MATCH_label_c980;  /*opt-block+*/
04949                                       
04950                                       break;
04951                                     case 2: 
04952                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
04953                                       if ((MATCH_w_8_16 & 0x7) 
04954                                               /* r_m at 16 */ == 4 && 
04955                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04956                                               /* index at 24 */ && 
04957                                         (MATCH_w_8_24 >> 3 & 0x7) 
04958                                               /* index at 24 */ < 8)) 
04959                                         goto MATCH_label_c981;  /*opt-block+*/
04960                                       else 
04961                                         goto MATCH_label_c982;  /*opt-block+*/
04962                                       
04963                                       break;
04964                                     case 3: 
04965                                       goto MATCH_label_c979; break;
04966                                     default: assert(0);
04967                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
04968                                         -- mod at 16 --*/ 
04969                                 
04970                                 break;
04971                               default: assert(0);
04972                             } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/  
04973                         else 
04974                           
04975                             switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
04976                               case 0: 
04977                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
04978                                 
04979                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
04980                                         /* mod at 16 */) {
04981                                     case 0: 
04982                                       
04983                                         switch((MATCH_w_8_16 & 0x7) 
04984                                               /* r_m at 16 */) {
04985                                           case 0: case 1: case 2: case 3: 
04986                                           case 6: case 7: 
04987                                             goto MATCH_label_c918; break;
04988                                           case 4: 
04989                                             MATCH_w_8_24 = 
04990                                               getByte(3 + MATCH_p); 
04991                                             if ((MATCH_w_8_24 & 0x7) 
04992                                                     /* base at 24 */ == 5 && 
04993                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04994                                                     /* index at 24 */ && 
04995                                               (MATCH_w_8_24 >> 3 & 0x7) 
04996                                                     /* index at 24 */ < 8)) 
04997                                               goto MATCH_label_c920;  /*opt-block+*/
04998                                             else 
04999                                               goto MATCH_label_c919;  /*opt-block+*/
05000                                             
05001                                             break;
05002                                           case 5: 
05003                                             goto MATCH_label_c921; break;
05004                                           default: assert(0);
05005                                         } /* (MATCH_w_8_16 & 0x7) 
05006                                               -- r_m at 16 --*/ 
05007                                       break;
05008                                     case 1: 
05009                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05010                                       if ((MATCH_w_8_16 & 0x7) 
05011                                               /* r_m at 16 */ == 4 && 
05012                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05013                                               /* index at 24 */ && 
05014                                         (MATCH_w_8_24 >> 3 & 0x7) 
05015                                               /* index at 24 */ < 8)) { 
05016                                         unsigned Eaddr = 
05017                                           2 + addressToPC(MATCH_p);
05018                                         unsigned reg = 
05019                                           (MATCH_w_8_16 >> 3 & 0x7) 
05020                                                 /* reg_opcode at 16 */;
05021                                         nextPC = 5 + MATCH_p; 
05022                                         
05023 #line 1244 "frontend/machine/pentium/decoder.m"
05024                                         
05025 
05026                                                 stmts = instantiate(pc,  "CMPXCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
05027 
05028                                         
05029 
05030                                         
05031                                         
05032                                         
05033                                       } /*opt-block*//*opt-block+*/
05034                                       else 
05035                                         goto MATCH_label_c919;  /*opt-block+*/
05036                                       
05037                                       break;
05038                                     case 2: 
05039                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05040                                       if ((MATCH_w_8_16 & 0x7) 
05041                                               /* r_m at 16 */ == 4 && 
05042                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05043                                               /* index at 24 */ && 
05044                                         (MATCH_w_8_24 >> 3 & 0x7) 
05045                                               /* index at 24 */ < 8)) 
05046                                         goto MATCH_label_c920;  /*opt-block+*/
05047                                       else 
05048                                         goto MATCH_label_c921;  /*opt-block+*/
05049                                       
05050                                       break;
05051                                     case 3: 
05052                                       goto MATCH_label_c918; break;
05053                                     default: assert(0);
05054                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
05055                                         -- mod at 16 --*/ 
05056                                 
05057                                 break;
05058                               case 1: 
05059                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
05060                                 
05061                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
05062                                         /* mod at 16 */) {
05063                                     case 0: 
05064                                       
05065                                         switch((MATCH_w_8_16 & 0x7) 
05066                                               /* r_m at 16 */) {
05067                                           case 0: case 1: case 2: case 3: 
05068                                           case 6: case 7: 
05069                                             goto MATCH_label_c922; break;
05070                                           case 4: 
05071                                             MATCH_w_8_24 = 
05072                                               getByte(3 + MATCH_p); 
05073                                             if ((MATCH_w_8_24 & 0x7) 
05074                                                     /* base at 24 */ == 5 && 
05075                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05076                                                     /* index at 24 */ && 
05077                                               (MATCH_w_8_24 >> 3 & 0x7) 
05078                                                     /* index at 24 */ < 8)) 
05079                                               goto MATCH_label_c924;  /*opt-block+*/
05080                                             else 
05081                                               goto MATCH_label_c923;  /*opt-block+*/
05082                                             
05083                                             break;
05084                                           case 5: 
05085                                             goto MATCH_label_c925; break;
05086                                           default: assert(0);
05087                                         } /* (MATCH_w_8_16 & 0x7) 
05088                                               -- r_m at 16 --*/ 
05089                                       break;
05090                                     case 1: 
05091                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05092                                       if ((MATCH_w_8_16 & 0x7) 
05093                                               /* r_m at 16 */ == 4 && 
05094                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05095                                               /* index at 24 */ && 
05096                                         (MATCH_w_8_24 >> 3 & 0x7) 
05097                                               /* index at 24 */ < 8)) { 
05098                                         unsigned Eaddr = 
05099                                           2 + addressToPC(MATCH_p);
05100                                         unsigned reg = 
05101                                           (MATCH_w_8_16 >> 3 & 0x7) 
05102                                                 /* reg_opcode at 16 */;
05103                                         nextPC = 5 + MATCH_p; 
05104                                         
05105 #line 1238 "frontend/machine/pentium/decoder.m"
05106                                         
05107 
05108                                                 stmts = instantiate(pc,  "CMPXCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
05109 
05110                                         
05111 
05112                                         
05113                                         
05114                                         
05115                                       } /*opt-block*//*opt-block+*/
05116                                       else 
05117                                         goto MATCH_label_c923;  /*opt-block+*/
05118                                       
05119                                       break;
05120                                     case 2: 
05121                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05122                                       if ((MATCH_w_8_16 & 0x7) 
05123                                               /* r_m at 16 */ == 4 && 
05124                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05125                                               /* index at 24 */ && 
05126                                         (MATCH_w_8_24 >> 3 & 0x7) 
05127                                               /* index at 24 */ < 8)) 
05128                                         goto MATCH_label_c924;  /*opt-block+*/
05129                                       else 
05130                                         goto MATCH_label_c925;  /*opt-block+*/
05131                                       
05132                                       break;
05133                                     case 3: 
05134                                       goto MATCH_label_c922; break;
05135                                     default: assert(0);
05136                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
05137                                         -- mod at 16 --*/ 
05138                                 
05139                                 break;
05140                               case 2: 
05141                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
05142                                 
05143                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
05144                                         /* mod at 16 */) {
05145                                     case 0: 
05146                                       
05147                                         switch((MATCH_w_8_16 & 0x7) 
05148                                               /* r_m at 16 */) {
05149                                           case 0: case 1: case 2: case 3: 
05150                                           case 6: case 7: 
05151                                             { 
05152                                               unsigned Mem = 
05153                                                 2 + addressToPC(MATCH_p);
05154                                               unsigned reg = 
05155                                                 (MATCH_w_8_16 >> 3 & 0x7) 
05156                                                       /* reg_opcode at 16 */;
05157                                               nextPC = 3 + MATCH_p; 
05158                                               
05159 #line 1043 "frontend/machine/pentium/decoder.m"
05160                                               
05161 
05162                                                     stmts = instantiate(pc,  "LSS", DIS_REG32, DIS_MEM);
05163 
05164                                               
05165 
05166                                               
05167                                               
05168                                               
05169                                             }
05170                                             
05171                                             break;
05172                                           case 4: 
05173                                             MATCH_w_8_24 = 
05174                                               getByte(3 + MATCH_p); 
05175                                             if ((MATCH_w_8_24 & 0x7) 
05176                                                     /* base at 24 */ == 5 && 
05177                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05178                                                     /* index at 24 */ && 
05179                                               (MATCH_w_8_24 >> 3 & 0x7) 
05180                                                     /* index at 24 */ < 8)) 
05181                                               goto MATCH_label_c927;  /*opt-block+*/
05182                                             else 
05183                                               goto MATCH_label_c926;  /*opt-block+*/
05184                                             
05185                                             break;
05186                                           case 5: 
05187                                             goto MATCH_label_c928; break;
05188                                           default: assert(0);
05189                                         } /* (MATCH_w_8_16 & 0x7) 
05190                                               -- r_m at 16 --*/ 
05191                                       break;
05192                                     case 1: 
05193                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05194                                       if ((MATCH_w_8_16 & 0x7) 
05195                                               /* r_m at 16 */ == 4 && 
05196                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05197                                               /* index at 24 */ && 
05198                                         (MATCH_w_8_24 >> 3 & 0x7) 
05199                                               /* index at 24 */ < 8)) { 
05200                                         unsigned Mem = 
05201                                           2 + addressToPC(MATCH_p);
05202                                         unsigned reg = 
05203                                           (MATCH_w_8_16 >> 3 & 0x7) 
05204                                                 /* reg_opcode at 16 */;
05205                                         nextPC = 5 + MATCH_p; 
05206                                         
05207 #line 1043 "frontend/machine/pentium/decoder.m"
05208                                         
05209 
05210                                                 stmts = instantiate(pc,  "LSS", DIS_REG32, DIS_MEM);
05211 
05212                                         
05213 
05214                                         
05215                                         
05216                                         
05217                                       } /*opt-block*//*opt-block+*/
05218                                       else 
05219                                         goto MATCH_label_c926;  /*opt-block+*/
05220                                       
05221                                       break;
05222                                     case 2: 
05223                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05224                                       if ((MATCH_w_8_16 & 0x7) 
05225                                               /* r_m at 16 */ == 4 && 
05226                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05227                                               /* index at 24 */ && 
05228                                         (MATCH_w_8_24 >> 3 & 0x7) 
05229                                               /* index at 24 */ < 8)) 
05230                                         goto MATCH_label_c927;  /*opt-block+*/
05231                                       else 
05232                                         goto MATCH_label_c928;  /*opt-block+*/
05233                                       
05234                                       break;
05235                                     case 3: 
05236                                       goto MATCH_label_c64; break;
05237                                     default: assert(0);
05238                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
05239                                         -- mod at 16 --*/ 
05240                                 
05241                                 break;
05242                               case 3: 
05243                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
05244                                 
05245                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
05246                                         /* mod at 16 */) {
05247                                     case 0: 
05248                                       
05249                                         switch((MATCH_w_8_16 & 0x7) 
05250                                               /* r_m at 16 */) {
05251                                           case 0: case 1: case 2: case 3: 
05252                                           case 6: case 7: 
05253                                             goto MATCH_label_c929; break;
05254                                           case 4: 
05255                                             MATCH_w_8_24 = 
05256                                               getByte(3 + MATCH_p); 
05257                                             if ((MATCH_w_8_24 & 0x7) 
05258                                                     /* base at 24 */ == 5 && 
05259                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05260                                                     /* index at 24 */ && 
05261                                               (MATCH_w_8_24 >> 3 & 0x7) 
05262                                                     /* index at 24 */ < 8)) 
05263                                               goto MATCH_label_c931;  /*opt-block+*/
05264                                             else 
05265                                               goto MATCH_label_c930;  /*opt-block+*/
05266                                             
05267                                             break;
05268                                           case 5: 
05269                                             goto MATCH_label_c932; break;
05270                                           default: assert(0);
05271                                         } /* (MATCH_w_8_16 & 0x7) 
05272                                               -- r_m at 16 --*/ 
05273                                       break;
05274                                     case 1: 
05275                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05276                                       if ((MATCH_w_8_16 & 0x7) 
05277                                               /* r_m at 16 */ == 4 && 
05278                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05279                                               /* index at 24 */ && 
05280                                         (MATCH_w_8_24 >> 3 & 0x7) 
05281                                               /* index at 24 */ < 8)) { 
05282                                         unsigned Eaddr = 
05283                                           2 + addressToPC(MATCH_p);
05284                                         unsigned reg = 
05285                                           (MATCH_w_8_16 >> 3 & 0x7) 
05286                                                 /* reg_opcode at 16 */;
05287                                         nextPC = 5 + MATCH_p; 
05288                                         
05289 #line 1328 "frontend/machine/pentium/decoder.m"
05290                                         
05291 
05292                                                 stmts = instantiate(pc,  "BTRod", DIS_EADDR32, DIS_REG32);
05293 
05294                                         
05295 
05296                                         
05297                                         
05298                                         
05299                                       } /*opt-block*//*opt-block+*/
05300                                       else 
05301                                         goto MATCH_label_c930;  /*opt-block+*/
05302                                       
05303                                       break;
05304                                     case 2: 
05305                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05306                                       if ((MATCH_w_8_16 & 0x7) 
05307                                               /* r_m at 16 */ == 4 && 
05308                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05309                                               /* index at 24 */ && 
05310                                         (MATCH_w_8_24 >> 3 & 0x7) 
05311                                               /* index at 24 */ < 8)) 
05312                                         goto MATCH_label_c931;  /*opt-block+*/
05313                                       else 
05314                                         goto MATCH_label_c932;  /*opt-block+*/
05315                                       
05316                                       break;
05317                                     case 3: 
05318                                       goto MATCH_label_c929; break;
05319                                     default: assert(0);
05320                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
05321                                         -- mod at 16 --*/ 
05322                                 
05323                                 break;
05324                               case 4: 
05325                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
05326                                 
05327                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
05328                                         /* mod at 16 */) {
05329                                     case 0: 
05330                                       
05331                                         switch((MATCH_w_8_16 & 0x7) 
05332                                               /* r_m at 16 */) {
05333                                           case 0: case 1: case 2: case 3: 
05334                                           case 6: case 7: 
05335                                             { 
05336                                               unsigned Mem = 
05337                                                 2 + addressToPC(MATCH_p);
05338                                               unsigned reg = 
05339                                                 (MATCH_w_8_16 >> 3 & 0x7) 
05340                                                       /* reg_opcode at 16 */;
05341                                               nextPC = 3 + MATCH_p; 
05342                                               
05343 #line 1064 "frontend/machine/pentium/decoder.m"
05344                                               
05345 
05346                                                     stmts = instantiate(pc,  "LFS", DIS_REG32, DIS_MEM);
05347 
05348                                               
05349 
05350                                               
05351                                               
05352                                               
05353                                             }
05354                                             
05355                                             break;
05356                                           case 4: 
05357                                             MATCH_w_8_24 = 
05358                                               getByte(3 + MATCH_p); 
05359                                             if ((MATCH_w_8_24 & 0x7) 
05360                                                     /* base at 24 */ == 5 && 
05361                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05362                                                     /* index at 24 */ && 
05363                                               (MATCH_w_8_24 >> 3 & 0x7) 
05364                                                     /* index at 24 */ < 8)) 
05365                                               goto MATCH_label_c934;  /*opt-block+*/
05366                                             else 
05367                                               goto MATCH_label_c933;  /*opt-block+*/
05368                                             
05369                                             break;
05370                                           case 5: 
05371                                             goto MATCH_label_c935; break;
05372                                           default: assert(0);
05373                                         } /* (MATCH_w_8_16 & 0x7) 
05374                                               -- r_m at 16 --*/ 
05375                                       break;
05376                                     case 1: 
05377                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05378                                       if ((MATCH_w_8_16 & 0x7) 
05379                                               /* r_m at 16 */ == 4 && 
05380                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05381                                               /* index at 24 */ && 
05382                                         (MATCH_w_8_24 >> 3 & 0x7) 
05383                                               /* index at 24 */ < 8)) { 
05384                                         unsigned Mem = 
05385                                           2 + addressToPC(MATCH_p);
05386                                         unsigned reg = 
05387                                           (MATCH_w_8_16 >> 3 & 0x7) 
05388                                                 /* reg_opcode at 16 */;
05389                                         nextPC = 5 + MATCH_p; 
05390                                         
05391 #line 1064 "frontend/machine/pentium/decoder.m"
05392                                         
05393 
05394                                                 stmts = instantiate(pc,  "LFS", DIS_REG32, DIS_MEM);
05395 
05396                                         
05397 
05398                                         
05399                                         
05400                                         
05401                                       } /*opt-block*//*opt-block+*/
05402                                       else 
05403                                         goto MATCH_label_c933;  /*opt-block+*/
05404                                       
05405                                       break;
05406                                     case 2: 
05407                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05408                                       if ((MATCH_w_8_16 & 0x7) 
05409                                               /* r_m at 16 */ == 4 && 
05410                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05411                                               /* index at 24 */ && 
05412                                         (MATCH_w_8_24 >> 3 & 0x7) 
05413                                               /* index at 24 */ < 8)) 
05414                                         goto MATCH_label_c934;  /*opt-block+*/
05415                                       else 
05416                                         goto MATCH_label_c935;  /*opt-block+*/
05417                                       
05418                                       break;
05419                                     case 3: 
05420                                       goto MATCH_label_c64; break;
05421                                     default: assert(0);
05422                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
05423                                         -- mod at 16 --*/ 
05424                                 
05425                                 break;
05426                               case 5: 
05427                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
05428                                 
05429                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
05430                                         /* mod at 16 */) {
05431                                     case 0: 
05432                                       
05433                                         switch((MATCH_w_8_16 & 0x7) 
05434                                               /* r_m at 16 */) {
05435                                           case 0: case 1: case 2: case 3: 
05436                                           case 6: case 7: 
05437                                             { 
05438                                               unsigned Mem = 
05439                                                 2 + addressToPC(MATCH_p);
05440                                               unsigned reg = 
05441                                                 (MATCH_w_8_16 >> 3 & 0x7) 
05442                                                       /* reg_opcode at 16 */;
05443                                               nextPC = 3 + MATCH_p; 
05444                                               
05445 #line 1061 "frontend/machine/pentium/decoder.m"
05446                                               
05447 
05448                                                     stmts = instantiate(pc,  "LGS", DIS_REG32, DIS_MEM);
05449 
05450                                               
05451 
05452                                               
05453                                               
05454                                               
05455                                             }
05456                                             
05457                                             break;
05458                                           case 4: 
05459                                             MATCH_w_8_24 = 
05460                                               getByte(3 + MATCH_p); 
05461                                             if ((MATCH_w_8_24 & 0x7) 
05462                                                     /* base at 24 */ == 5 && 
05463                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05464                                                     /* index at 24 */ && 
05465                                               (MATCH_w_8_24 >> 3 & 0x7) 
05466                                                     /* index at 24 */ < 8)) 
05467                                               goto MATCH_label_c937;  /*opt-block+*/
05468                                             else 
05469                                               goto MATCH_label_c936;  /*opt-block+*/
05470                                             
05471                                             break;
05472                                           case 5: 
05473                                             goto MATCH_label_c938; break;
05474                                           default: assert(0);
05475                                         } /* (MATCH_w_8_16 & 0x7) 
05476                                               -- r_m at 16 --*/ 
05477                                       break;
05478                                     case 1: 
05479                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05480                                       if ((MATCH_w_8_16 & 0x7) 
05481                                               /* r_m at 16 */ == 4 && 
05482                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05483                                               /* index at 24 */ && 
05484                                         (MATCH_w_8_24 >> 3 & 0x7) 
05485                                               /* index at 24 */ < 8)) { 
05486                                         unsigned Mem = 
05487                                           2 + addressToPC(MATCH_p);
05488                                         unsigned reg = 
05489                                           (MATCH_w_8_16 >> 3 & 0x7) 
05490                                                 /* reg_opcode at 16 */;
05491                                         nextPC = 5 + MATCH_p; 
05492                                         
05493 #line 1061 "frontend/machine/pentium/decoder.m"
05494                                         
05495 
05496                                                 stmts = instantiate(pc,  "LGS", DIS_REG32, DIS_MEM);
05497 
05498                                         
05499 
05500                                         
05501                                         
05502                                         
05503                                       } /*opt-block*//*opt-block+*/
05504                                       else 
05505                                         goto MATCH_label_c936;  /*opt-block+*/
05506                                       
05507                                       break;
05508                                     case 2: 
05509                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05510                                       if ((MATCH_w_8_16 & 0x7) 
05511                                               /* r_m at 16 */ == 4 && 
05512                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05513                                               /* index at 24 */ && 
05514                                         (MATCH_w_8_24 >> 3 & 0x7) 
05515                                               /* index at 24 */ < 8)) 
05516                                         goto MATCH_label_c937;  /*opt-block+*/
05517                                       else 
05518                                         goto MATCH_label_c938;  /*opt-block+*/
05519                                       
05520                                       break;
05521                                     case 3: 
05522                                       goto MATCH_label_c64; break;
05523                                     default: assert(0);
05524                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
05525                                         -- mod at 16 --*/ 
05526                                 
05527                                 break;
05528                               case 6: 
05529                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
05530                                 
05531                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
05532                                         /* mod at 16 */) {
05533                                     case 0: 
05534                                       
05535                                         switch((MATCH_w_8_16 & 0x7) 
05536                                               /* r_m at 16 */) {
05537                                           case 0: case 1: case 2: case 3: 
05538                                           case 6: case 7: 
05539                                             goto MATCH_label_c939; break;
05540                                           case 4: 
05541                                             MATCH_w_8_24 = 
05542                                               getByte(3 + MATCH_p); 
05543                                             if ((MATCH_w_8_24 & 0x7) 
05544                                                     /* base at 24 */ == 5 && 
05545                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05546                                                     /* index at 24 */ && 
05547                                               (MATCH_w_8_24 >> 3 & 0x7) 
05548                                                     /* index at 24 */ < 8)) 
05549                                               goto MATCH_label_c941;  /*opt-block+*/
05550                                             else 
05551                                               goto MATCH_label_c940;  /*opt-block+*/
05552                                             
05553                                             break;
05554                                           case 5: 
05555                                             goto MATCH_label_c942; break;
05556                                           default: assert(0);
05557                                         } /* (MATCH_w_8_16 & 0x7) 
05558                                               -- r_m at 16 --*/ 
05559                                       break;
05560                                     case 1: 
05561                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05562                                       if ((MATCH_w_8_16 & 0x7) 
05563                                               /* r_m at 16 */ == 4 && 
05564                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05565                                               /* index at 24 */ && 
05566                                         (MATCH_w_8_24 >> 3 & 0x7) 
05567                                               /* index at 24 */ < 8)) { 
05568                                         unsigned Eaddr = 
05569                                           2 + addressToPC(MATCH_p);
05570                                         unsigned r32 = 
05571                                           (MATCH_w_8_16 >> 3 & 0x7) 
05572                                                 /* reg_opcode at 16 */;
05573                                         nextPC = 5 + MATCH_p; 
05574                                         
05575 #line 940 "frontend/machine/pentium/decoder.m"
05576                                         
05577 
05578                                                 stmts = instantiate(pc,  "MOVZX.Gv.Ebod", DIS_R32, DIS_EADDR8);
05579 
05580                                         
05581 
05582                                         
05583                                         
05584                                         
05585                                       } /*opt-block*//*opt-block+*/
05586                                       else 
05587                                         goto MATCH_label_c940;  /*opt-block+*/
05588                                       
05589                                       break;
05590                                     case 2: 
05591                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05592                                       if ((MATCH_w_8_16 & 0x7) 
05593                                               /* r_m at 16 */ == 4 && 
05594                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05595                                               /* index at 24 */ && 
05596                                         (MATCH_w_8_24 >> 3 & 0x7) 
05597                                               /* index at 24 */ < 8)) 
05598                                         goto MATCH_label_c941;  /*opt-block+*/
05599                                       else 
05600                                         goto MATCH_label_c942;  /*opt-block+*/
05601                                       
05602                                       break;
05603                                     case 3: 
05604                                       goto MATCH_label_c939; break;
05605                                     default: assert(0);
05606                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
05607                                         -- mod at 16 --*/ 
05608                                 
05609                                 break;
05610                               case 7: 
05611                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
05612                                 
05613                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
05614                                         /* mod at 16 */) {
05615                                     case 0: 
05616                                       
05617                                         switch((MATCH_w_8_16 & 0x7) 
05618                                               /* r_m at 16 */) {
05619                                           case 0: case 1: case 2: case 3: 
05620                                           case 6: case 7: 
05621                                             goto MATCH_label_c943; break;
05622                                           case 4: 
05623                                             MATCH_w_8_24 = 
05624                                               getByte(3 + MATCH_p); 
05625                                             if ((MATCH_w_8_24 & 0x7) 
05626                                                     /* base at 24 */ == 5 && 
05627                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05628                                                     /* index at 24 */ && 
05629                                               (MATCH_w_8_24 >> 3 & 0x7) 
05630                                                     /* index at 24 */ < 8)) 
05631                                               goto MATCH_label_c945;  /*opt-block+*/
05632                                             else 
05633                                               goto MATCH_label_c944;  /*opt-block+*/
05634                                             
05635                                             break;
05636                                           case 5: 
05637                                             goto MATCH_label_c946; break;
05638                                           default: assert(0);
05639                                         } /* (MATCH_w_8_16 & 0x7) 
05640                                               -- r_m at 16 --*/ 
05641                                       break;
05642                                     case 1: 
05643                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05644                                       if ((MATCH_w_8_16 & 0x7) 
05645                                               /* r_m at 16 */ == 4 && 
05646                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05647                                               /* index at 24 */ && 
05648                                         (MATCH_w_8_24 >> 3 & 0x7) 
05649                                               /* index at 24 */ < 8)) { 
05650                                         unsigned Eaddr = 
05651                                           2 + addressToPC(MATCH_p);
05652                                         unsigned r32 = 
05653                                           (MATCH_w_8_16 >> 3 & 0x7) 
05654                                                 /* reg_opcode at 16 */;
05655                                         nextPC = 5 + MATCH_p; 
05656                                         
05657 #line 937 "frontend/machine/pentium/decoder.m"
05658                                         
05659 
05660                                                 stmts = instantiate(pc,  "MOVZX.Gv.Ew", DIS_R32, DIS_EADDR16);
05661 
05662                                         
05663 
05664                                         
05665                                         
05666                                         
05667                                       } /*opt-block*//*opt-block+*/
05668                                       else 
05669                                         goto MATCH_label_c944;  /*opt-block+*/
05670                                       
05671                                       break;
05672                                     case 2: 
05673                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05674                                       if ((MATCH_w_8_16 & 0x7) 
05675                                               /* r_m at 16 */ == 4 && 
05676                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05677                                               /* index at 24 */ && 
05678                                         (MATCH_w_8_24 >> 3 & 0x7) 
05679                                               /* index at 24 */ < 8)) 
05680                                         goto MATCH_label_c945;  /*opt-block+*/
05681                                       else 
05682                                         goto MATCH_label_c946;  /*opt-block+*/
05683                                       
05684                                       break;
05685                                     case 3: 
05686                                       goto MATCH_label_c943; break;
05687                                     default: assert(0);
05688                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
05689                                         -- mod at 16 --*/ 
05690                                 
05691                                 break;
05692                               default: assert(0);
05693                             } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/  
05694                         break;
05695                       case 12: 
05696                         if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) { 
05697                           unsigned r32 = (MATCH_w_8_8 & 0x7) /* r32 at 8 */;
05698                           nextPC = 2 + MATCH_p; 
05699                           
05700 #line 1358 "frontend/machine/pentium/decoder.m"
05701                           
05702 
05703                                 stmts = instantiate(pc,  "BSWAP", DIS_R32);
05704 
05705                           
05706 
05707                           
05708                           
05709                           
05710                         } /*opt-block*//*opt-block+*/
05711                         else 
05712                           
05713                             switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
05714                               case 0: 
05715                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
05716                                 
05717                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
05718                                         /* mod at 16 */) {
05719                                     case 0: 
05720                                       
05721                                         switch((MATCH_w_8_16 & 0x7) 
05722                                               /* r_m at 16 */) {
05723                                           case 0: case 1: case 2: case 3: 
05724                                           case 6: case 7: 
05725                                             goto MATCH_label_c983; break;
05726                                           case 4: 
05727                                             MATCH_w_8_24 = 
05728                                               getByte(3 + MATCH_p); 
05729                                             if ((MATCH_w_8_24 & 0x7) 
05730                                                     /* base at 24 */ == 5 && 
05731                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05732                                                     /* index at 24 */ && 
05733                                               (MATCH_w_8_24 >> 3 & 0x7) 
05734                                                     /* index at 24 */ < 8)) 
05735                                               goto MATCH_label_c985;  /*opt-block+*/
05736                                             else 
05737                                               goto MATCH_label_c984;  /*opt-block+*/
05738                                             
05739                                             break;
05740                                           case 5: 
05741                                             goto MATCH_label_c986; break;
05742                                           default: assert(0);
05743                                         } /* (MATCH_w_8_16 & 0x7) 
05744                                               -- r_m at 16 --*/ 
05745                                       break;
05746                                     case 1: 
05747                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05748                                       if ((MATCH_w_8_16 & 0x7) 
05749                                               /* r_m at 16 */ == 4 && 
05750                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05751                                               /* index at 24 */ && 
05752                                         (MATCH_w_8_24 >> 3 & 0x7) 
05753                                               /* index at 24 */ < 8)) { 
05754                                         unsigned Eaddr = 
05755                                           2 + addressToPC(MATCH_p);
05756                                         unsigned reg = 
05757                                           (MATCH_w_8_16 >> 3 & 0x7) 
05758                                                 /* reg_opcode at 16 */;
05759                                         nextPC = 5 + MATCH_p; 
05760                                         
05761 #line 360 "frontend/machine/pentium/decoder.m"
05762                                         
05763 
05764                                                 stmts = instantiate(pc,  "XADD.Eb.Gb", DIS_EADDR8, DIS_REG8);
05765 
05766                                         
05767 
05768                                         
05769                                         
05770                                         
05771                                       } /*opt-block*//*opt-block+*/
05772                                       else 
05773                                         goto MATCH_label_c984;  /*opt-block+*/
05774                                       
05775                                       break;
05776                                     case 2: 
05777                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05778                                       if ((MATCH_w_8_16 & 0x7) 
05779                                               /* r_m at 16 */ == 4 && 
05780                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05781                                               /* index at 24 */ && 
05782                                         (MATCH_w_8_24 >> 3 & 0x7) 
05783                                               /* index at 24 */ < 8)) 
05784                                         goto MATCH_label_c985;  /*opt-block+*/
05785                                       else 
05786                                         goto MATCH_label_c986;  /*opt-block+*/
05787                                       
05788                                       break;
05789                                     case 3: 
05790                                       goto MATCH_label_c983; break;
05791                                     default: assert(0);
05792                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
05793                                         -- mod at 16 --*/ 
05794                                 
05795                                 break;
05796                               case 1: 
05797                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
05798                                 
05799                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
05800                                         /* mod at 16 */) {
05801                                     case 0: 
05802                                       
05803                                         switch((MATCH_w_8_16 & 0x7) 
05804                                               /* r_m at 16 */) {
05805                                           case 0: case 1: case 2: case 3: 
05806                                           case 6: case 7: 
05807                                             goto MATCH_label_c987; break;
05808                                           case 4: 
05809                                             MATCH_w_8_24 = 
05810                                               getByte(3 + MATCH_p); 
05811                                             if ((MATCH_w_8_24 & 0x7) 
05812                                                     /* base at 24 */ == 5 && 
05813                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05814                                                     /* index at 24 */ && 
05815                                               (MATCH_w_8_24 >> 3 & 0x7) 
05816                                                     /* index at 24 */ < 8)) 
05817                                               goto MATCH_label_c989;  /*opt-block+*/
05818                                             else 
05819                                               goto MATCH_label_c988;  /*opt-block+*/
05820                                             
05821                                             break;
05822                                           case 5: 
05823                                             goto MATCH_label_c990; break;
05824                                           default: assert(0);
05825                                         } /* (MATCH_w_8_16 & 0x7) 
05826                                               -- r_m at 16 --*/ 
05827                                       break;
05828                                     case 1: 
05829                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05830                                       if ((MATCH_w_8_16 & 0x7) 
05831                                               /* r_m at 16 */ == 4 && 
05832                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05833                                               /* index at 24 */ && 
05834                                         (MATCH_w_8_24 >> 3 & 0x7) 
05835                                               /* index at 24 */ < 8)) { 
05836                                         unsigned Eaddr = 
05837                                           2 + addressToPC(MATCH_p);
05838                                         unsigned reg = 
05839                                           (MATCH_w_8_16 >> 3 & 0x7) 
05840                                                 /* reg_opcode at 16 */;
05841                                         nextPC = 5 + MATCH_p; 
05842                                         
05843 #line 354 "frontend/machine/pentium/decoder.m"
05844                                         
05845 
05846                                                 stmts = instantiate(pc,  "XADD.Ev.Gvod", DIS_EADDR32, DIS_REG32);
05847 
05848                                         
05849 
05850                                         
05851                                         
05852                                         
05853                                       } /*opt-block*//*opt-block+*/
05854                                       else 
05855                                         goto MATCH_label_c988;  /*opt-block+*/
05856                                       
05857                                       break;
05858                                     case 2: 
05859                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
05860                                       if ((MATCH_w_8_16 & 0x7) 
05861                                               /* r_m at 16 */ == 4 && 
05862                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05863                                               /* index at 24 */ && 
05864                                         (MATCH_w_8_24 >> 3 & 0x7) 
05865                                               /* index at 24 */ < 8)) 
05866                                         goto MATCH_label_c989;  /*opt-block+*/
05867                                       else 
05868                                         goto MATCH_label_c990;  /*opt-block+*/
05869                                       
05870                                       break;
05871                                     case 3: 
05872                                       goto MATCH_label_c987; break;
05873                                     default: assert(0);
05874                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
05875                                         -- mod at 16 --*/ 
05876                                 
05877                                 break;
05878                               case 2: case 3: case 4: case 5: case 6: 
05879                                 goto MATCH_label_c64; break;
05880                               case 7: 
05881                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
05882                                 if ((MATCH_w_8_16 >> 3 & 0x7) 
05883                                         /* reg_opcode at 16 */ == 1) 
05884                                   
05885                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
05886                                           /* mod at 16 */) {
05887                                       case 0: 
05888                                         
05889                                           switch((MATCH_w_8_16 & 0x7) 
05890                                                 /* r_m at 16 */) {
05891                                             case 0: case 1: case 2: case 3: 
05892                                             case 6: case 7: 
05893                                               { 
05894                                                 unsigned Mem = 
05895                                                   2 + addressToPC(MATCH_p);
05896                                                 nextPC = 3 + MATCH_p; 
05897                                                 
05898 #line 1235 "frontend/machine/pentium/decoder.m"
05899                                                 
05900 
05901                                                         stmts = instantiate(pc,  "CMPXCHG8B", DIS_MEM);
05902 
05903                                                 
05904 
05905                                                 
05906                                                 
05907                                                 
05908                                               }
05909                                               
05910                                               break;
05911                                             case 4: 
05912                                               MATCH_w_8_24 = 
05913                                                 getByte(3 + MATCH_p); 
05914                                               if ((MATCH_w_8_24 & 0x7) 
05915                                                       /* base at 24 */ == 5 && 
05916                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05917                                                       /* index at 24 */ && 
05918                                                 (MATCH_w_8_24 >> 3 & 0x7) 
05919                                                       /* index at 24 */ < 8)) 
05920                                                 goto MATCH_label_c992;  /*opt-block+*/
05921                                               else 
05922                                                 goto MATCH_label_c991;  /*opt-block+*/
05923                                               
05924                                               break;
05925                                             case 5: 
05926                                               goto MATCH_label_c993; break;
05927                                             default: assert(0);
05928                                           } /* (MATCH_w_8_16 & 0x7) 
05929                                                 -- r_m at 16 --*/ 
05930                                         break;
05931                                       case 1: 
05932                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
05933                                         if ((MATCH_w_8_16 & 0x7) 
05934                                                 /* r_m at 16 */ == 4 && 
05935                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05936                                                 /* index at 24 */ && 
05937                                           (MATCH_w_8_24 >> 3 & 0x7) 
05938                                                 /* index at 24 */ < 8)) { 
05939                                           unsigned Mem = 
05940                                             2 + addressToPC(MATCH_p);
05941                                           nextPC = 5 + MATCH_p; 
05942                                           
05943 #line 1235 "frontend/machine/pentium/decoder.m"
05944                                           
05945 
05946                                                 stmts = instantiate(pc,  "CMPXCHG8B", DIS_MEM);
05947 
05948                                           
05949 
05950                                           
05951                                           
05952                                           
05953                                         } /*opt-block*//*opt-block+*/
05954                                         else 
05955                                           goto MATCH_label_c991;  /*opt-block+*/
05956                                         
05957                                         break;
05958                                       case 2: 
05959                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
05960                                         if ((MATCH_w_8_16 & 0x7) 
05961                                                 /* r_m at 16 */ == 4 && 
05962                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
05963                                                 /* index at 24 */ && 
05964                                           (MATCH_w_8_24 >> 3 & 0x7) 
05965                                                 /* index at 24 */ < 8)) 
05966                                           goto MATCH_label_c992;  /*opt-block+*/
05967                                         else 
05968                                           goto MATCH_label_c993;  /*opt-block+*/
05969                                         
05970                                         break;
05971                                       case 3: 
05972                                         goto MATCH_label_c64; break;
05973                                       default: assert(0);
05974                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
05975                                           -- mod at 16 --*/  
05976                                 else 
05977                                   goto MATCH_label_c64;  /*opt-block+*/
05978                                 
05979                                 break;
05980                               default: assert(0);
05981                             } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/  
05982                         break;
05983                       default: assert(0);
05984                     } /* (MATCH_w_8_8 >> 4 & 0xf) -- row at 8 --*/ 
05985                   
05986                   break;
05987                 default: assert(0);
05988               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
05989             break;
05990           case 1: 
05991             
05992               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
05993                 case 0: 
05994                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
05995                   
05996                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
05997                       case 0: 
05998                         
05999                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06000                             case 0: case 1: case 2: case 3: case 6: case 7: 
06001                               goto MATCH_label_c994; break;
06002                             case 4: 
06003                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06004                               if ((MATCH_w_8_16 & 0x7) 
06005                                       /* base at 16 */ == 5 && 
06006                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06007                                       /* index at 16 */ && 
06008                                 (MATCH_w_8_16 >> 3 & 0x7) 
06009                                       /* index at 16 */ < 8)) 
06010                                 goto MATCH_label_c996;  /*opt-block+*/
06011                               else 
06012                                 goto MATCH_label_c995;  /*opt-block+*/
06013                               
06014                               break;
06015                             case 5: 
06016                               goto MATCH_label_c997; break;
06017                             default: assert(0);
06018                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06019                         break;
06020                       case 1: 
06021                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06022                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06023                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06024                                 /* index at 16 */ && 
06025                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06026                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06027                           unsigned r8 = 
06028                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06029                           nextPC = 4 + MATCH_p; 
06030                           
06031 #line 1537 "frontend/machine/pentium/decoder.m"
06032                           
06033 
06034                                 stmts = instantiate(pc,  "SBBmrb", DIS_EADDR8, DIS_R8);
06035 
06036                           
06037 
06038                           
06039                           
06040                           
06041                         } /*opt-block*//*opt-block+*/
06042                         else 
06043                           goto MATCH_label_c995;  /*opt-block+*/
06044                         
06045                         break;
06046                       case 2: 
06047                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06048                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06049                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06050                                 /* index at 16 */ && 
06051                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06052                           goto MATCH_label_c996;  /*opt-block+*/
06053                         else 
06054                           goto MATCH_label_c997;  /*opt-block+*/
06055                         
06056                         break;
06057                       case 3: 
06058                         goto MATCH_label_c994; break;
06059                       default: assert(0);
06060                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06061                   
06062                   break;
06063                 case 1: 
06064                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06065                   
06066                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06067                       case 0: 
06068                         
06069                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06070                             case 0: case 1: case 2: case 3: case 6: case 7: 
06071                               goto MATCH_label_c998; break;
06072                             case 4: 
06073                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06074                               if ((MATCH_w_8_16 & 0x7) 
06075                                       /* base at 16 */ == 5 && 
06076                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06077                                       /* index at 16 */ && 
06078                                 (MATCH_w_8_16 >> 3 & 0x7) 
06079                                       /* index at 16 */ < 8)) 
06080                                 goto MATCH_label_c1000;  /*opt-block+*/
06081                               else 
06082                                 goto MATCH_label_c999;  /*opt-block+*/
06083                               
06084                               break;
06085                             case 5: 
06086                               goto MATCH_label_c1001; break;
06087                             default: assert(0);
06088                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06089                         break;
06090                       case 1: 
06091                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06092                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06093                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06094                                 /* index at 16 */ && 
06095                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06096                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06097                           unsigned reg = 
06098                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06099                           nextPC = 4 + MATCH_p; 
06100                           
06101 #line 1501 "frontend/machine/pentium/decoder.m"
06102                           
06103 
06104                                 stmts = instantiate(pc,  "SBBmrod", DIS_EADDR32, DIS_REG32);
06105 
06106                           
06107 
06108                           
06109                           
06110                           
06111                         } /*opt-block*//*opt-block+*/
06112                         else 
06113                           goto MATCH_label_c999;  /*opt-block+*/
06114                         
06115                         break;
06116                       case 2: 
06117                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06118                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06119                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06120                                 /* index at 16 */ && 
06121                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06122                           goto MATCH_label_c1000;  /*opt-block+*/
06123                         else 
06124                           goto MATCH_label_c1001;  /*opt-block+*/
06125                         
06126                         break;
06127                       case 3: 
06128                         goto MATCH_label_c998; break;
06129                       default: assert(0);
06130                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06131                   
06132                   break;
06133                 case 2: 
06134                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06135                   
06136                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06137                       case 0: 
06138                         
06139                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06140                             case 0: case 1: case 2: case 3: case 6: case 7: 
06141                               goto MATCH_label_c1002; break;
06142                             case 4: 
06143                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06144                               if ((MATCH_w_8_16 & 0x7) 
06145                                       /* base at 16 */ == 5 && 
06146                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06147                                       /* index at 16 */ && 
06148                                 (MATCH_w_8_16 >> 3 & 0x7) 
06149                                       /* index at 16 */ < 8)) 
06150                                 goto MATCH_label_c1004;  /*opt-block+*/
06151                               else 
06152                                 goto MATCH_label_c1003;  /*opt-block+*/
06153                               
06154                               break;
06155                             case 5: 
06156                               goto MATCH_label_c1005; break;
06157                             default: assert(0);
06158                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06159                         break;
06160                       case 1: 
06161                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06162                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06163                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06164                                 /* index at 16 */ && 
06165                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06166                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06167                           unsigned r8 = 
06168                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06169                           nextPC = 4 + MATCH_p; 
06170                           
06171 #line 1465 "frontend/machine/pentium/decoder.m"
06172                           
06173 
06174                                 stmts = instantiate(pc,  "SBBrmb", DIS_R8, DIS_EADDR8);
06175 
06176                           
06177 
06178                           
06179                           
06180                           
06181                         } /*opt-block*//*opt-block+*/
06182                         else 
06183                           goto MATCH_label_c1003;  /*opt-block+*/
06184                         
06185                         break;
06186                       case 2: 
06187                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06188                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06189                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06190                                 /* index at 16 */ && 
06191                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06192                           goto MATCH_label_c1004;  /*opt-block+*/
06193                         else 
06194                           goto MATCH_label_c1005;  /*opt-block+*/
06195                         
06196                         break;
06197                       case 3: 
06198                         goto MATCH_label_c1002; break;
06199                       default: assert(0);
06200                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06201                   
06202                   break;
06203                 case 3: 
06204                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06205                   
06206                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06207                       case 0: 
06208                         
06209                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06210                             case 0: case 1: case 2: case 3: case 6: case 7: 
06211                               goto MATCH_label_c1006; break;
06212                             case 4: 
06213                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06214                               if ((MATCH_w_8_16 & 0x7) 
06215                                       /* base at 16 */ == 5 && 
06216                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06217                                       /* index at 16 */ && 
06218                                 (MATCH_w_8_16 >> 3 & 0x7) 
06219                                       /* index at 16 */ < 8)) 
06220                                 goto MATCH_label_c1008;  /*opt-block+*/
06221                               else 
06222                                 goto MATCH_label_c1007;  /*opt-block+*/
06223                               
06224                               break;
06225                             case 5: 
06226                               goto MATCH_label_c1009; break;
06227                             default: assert(0);
06228                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06229                         break;
06230                       case 1: 
06231                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06232                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06233                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06234                                 /* index at 16 */ && 
06235                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06236                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06237                           unsigned reg = 
06238                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06239                           nextPC = 4 + MATCH_p; 
06240                           
06241 #line 1429 "frontend/machine/pentium/decoder.m"
06242                           
06243 
06244                                 stmts = instantiate(pc,  "SBBrmod", DIS_REG32, DIS_EADDR32);
06245 
06246                           
06247 
06248                           
06249                           
06250                           
06251                         } /*opt-block*//*opt-block+*/
06252                         else 
06253                           goto MATCH_label_c1007;  /*opt-block+*/
06254                         
06255                         break;
06256                       case 2: 
06257                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06258                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06259                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06260                                 /* index at 16 */ && 
06261                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06262                           goto MATCH_label_c1008;  /*opt-block+*/
06263                         else 
06264                           goto MATCH_label_c1009;  /*opt-block+*/
06265                         
06266                         break;
06267                       case 3: 
06268                         goto MATCH_label_c1006; break;
06269                       default: assert(0);
06270                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06271                   
06272                   break;
06273                 case 4: 
06274                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06275                   { 
06276                     int /* [~128..127] */ i8 = 
06277                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
06278                     nextPC = 2 + MATCH_p; 
06279                     
06280 #line 1732 "frontend/machine/pentium/decoder.m"
06281                     
06282 
06283                             stmts = instantiate(pc,  "SBBiAL", DIS_I8);
06284 
06285                     
06286 
06287                     
06288                     
06289                     
06290                   }
06291                   
06292                   break;
06293                 case 5: 
06294                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
06295                   { 
06296                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
06297                     nextPC = 5 + MATCH_p; 
06298                     
06299 #line 1684 "frontend/machine/pentium/decoder.m"
06300                     
06301 
06302                             stmts = instantiate(pc,  "SBBiEAX", DIS_I32);
06303 
06304                     
06305 
06306                     
06307                     
06308                     
06309                   }
06310                   
06311                   break;
06312                 case 6: 
06313                   nextPC = 1 + MATCH_p; 
06314                   
06315 #line 811 "frontend/machine/pentium/decoder.m"
06316                   
06317 
06318                         stmts = instantiate(pc,  "PUSH.DS");
06319 
06320                   
06321 
06322                   
06323                   
06324                   
06325                   
06326                   break;
06327                 case 7: 
06328                   nextPC = 1 + MATCH_p; 
06329                   
06330 #line 862 "frontend/machine/pentium/decoder.m"
06331                   
06332 
06333                         stmts = instantiate(pc,  "POP.DS");
06334 
06335                   
06336 
06337                   
06338                   
06339                   
06340                   
06341                   break;
06342                 default: assert(0);
06343               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
06344             break;
06345           case 2: 
06346             
06347               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
06348                 case 0: 
06349                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06350                   
06351                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06352                       case 0: 
06353                         
06354                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06355                             case 0: case 1: case 2: case 3: case 6: case 7: 
06356                               goto MATCH_label_c1010; break;
06357                             case 4: 
06358                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06359                               if ((MATCH_w_8_16 & 0x7) 
06360                                       /* base at 16 */ == 5 && 
06361                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06362                                       /* index at 16 */ && 
06363                                 (MATCH_w_8_16 >> 3 & 0x7) 
06364                                       /* index at 16 */ < 8)) 
06365                                 goto MATCH_label_c1012;  /*opt-block+*/
06366                               else 
06367                                 goto MATCH_label_c1011;  /*opt-block+*/
06368                               
06369                               break;
06370                             case 5: 
06371                               goto MATCH_label_c1013; break;
06372                             default: assert(0);
06373                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06374                         break;
06375                       case 1: 
06376                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06377                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06378                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06379                                 /* index at 16 */ && 
06380                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06381                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06382                           unsigned r8 = 
06383                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06384                           nextPC = 4 + MATCH_p; 
06385                           
06386 #line 1531 "frontend/machine/pentium/decoder.m"
06387                           
06388 
06389                                 stmts = instantiate(pc,  "SUBmrb", DIS_EADDR8, DIS_R8);
06390 
06391                           
06392 
06393                           
06394                           
06395                           
06396                         } /*opt-block*//*opt-block+*/
06397                         else 
06398                           goto MATCH_label_c1011;  /*opt-block+*/
06399                         
06400                         break;
06401                       case 2: 
06402                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06403                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06404                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06405                                 /* index at 16 */ && 
06406                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06407                           goto MATCH_label_c1012;  /*opt-block+*/
06408                         else 
06409                           goto MATCH_label_c1013;  /*opt-block+*/
06410                         
06411                         break;
06412                       case 3: 
06413                         goto MATCH_label_c1010; break;
06414                       default: assert(0);
06415                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06416                   
06417                   break;
06418                 case 1: 
06419                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06420                   
06421                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06422                       case 0: 
06423                         
06424                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06425                             case 0: case 1: case 2: case 3: case 6: case 7: 
06426                               goto MATCH_label_c1014; break;
06427                             case 4: 
06428                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06429                               if ((MATCH_w_8_16 & 0x7) 
06430                                       /* base at 16 */ == 5 && 
06431                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06432                                       /* index at 16 */ && 
06433                                 (MATCH_w_8_16 >> 3 & 0x7) 
06434                                       /* index at 16 */ < 8)) 
06435                                 goto MATCH_label_c1016;  /*opt-block+*/
06436                               else 
06437                                 goto MATCH_label_c1015;  /*opt-block+*/
06438                               
06439                               break;
06440                             case 5: 
06441                               goto MATCH_label_c1017; break;
06442                             default: assert(0);
06443                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06444                         break;
06445                       case 1: 
06446                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06447                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06448                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06449                                 /* index at 16 */ && 
06450                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06451                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06452                           unsigned reg = 
06453                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06454                           nextPC = 4 + MATCH_p; 
06455                           
06456 #line 1489 "frontend/machine/pentium/decoder.m"
06457                           
06458 
06459                                 stmts = instantiate(pc,  "SUBmrod", DIS_EADDR32, DIS_REG32);
06460 
06461                           
06462 
06463                           
06464                           
06465                           
06466                         } /*opt-block*//*opt-block+*/
06467                         else 
06468                           goto MATCH_label_c1015;  /*opt-block+*/
06469                         
06470                         break;
06471                       case 2: 
06472                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06473                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06474                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06475                                 /* index at 16 */ && 
06476                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06477                           goto MATCH_label_c1016;  /*opt-block+*/
06478                         else 
06479                           goto MATCH_label_c1017;  /*opt-block+*/
06480                         
06481                         break;
06482                       case 3: 
06483                         goto MATCH_label_c1014; break;
06484                       default: assert(0);
06485                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06486                   
06487                   break;
06488                 case 2: 
06489                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06490                   
06491                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06492                       case 0: 
06493                         
06494                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06495                             case 0: case 1: case 2: case 3: case 6: case 7: 
06496                               goto MATCH_label_c1018; break;
06497                             case 4: 
06498                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06499                               if ((MATCH_w_8_16 & 0x7) 
06500                                       /* base at 16 */ == 5 && 
06501                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06502                                       /* index at 16 */ && 
06503                                 (MATCH_w_8_16 >> 3 & 0x7) 
06504                                       /* index at 16 */ < 8)) 
06505                                 goto MATCH_label_c1020;  /*opt-block+*/
06506                               else 
06507                                 goto MATCH_label_c1019;  /*opt-block+*/
06508                               
06509                               break;
06510                             case 5: 
06511                               goto MATCH_label_c1021; break;
06512                             default: assert(0);
06513                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06514                         break;
06515                       case 1: 
06516                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06517                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06518                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06519                                 /* index at 16 */ && 
06520                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06521                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06522                           unsigned r8 = 
06523                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06524                           nextPC = 4 + MATCH_p; 
06525                           
06526 #line 1459 "frontend/machine/pentium/decoder.m"
06527                           
06528 
06529                                 stmts = instantiate(pc,  "SUBrmb", DIS_R8, DIS_EADDR8);
06530 
06531                           
06532 
06533                           
06534                           
06535                           
06536                         } /*opt-block*//*opt-block+*/
06537                         else 
06538                           goto MATCH_label_c1019;  /*opt-block+*/
06539                         
06540                         break;
06541                       case 2: 
06542                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06543                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06544                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06545                                 /* index at 16 */ && 
06546                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06547                           goto MATCH_label_c1020;  /*opt-block+*/
06548                         else 
06549                           goto MATCH_label_c1021;  /*opt-block+*/
06550                         
06551                         break;
06552                       case 3: 
06553                         goto MATCH_label_c1018; break;
06554                       default: assert(0);
06555                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06556                   
06557                   break;
06558                 case 3: 
06559                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06560                   
06561                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06562                       case 0: 
06563                         
06564                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06565                             case 0: case 1: case 2: case 3: case 6: case 7: 
06566                               goto MATCH_label_c1022; break;
06567                             case 4: 
06568                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06569                               if ((MATCH_w_8_16 & 0x7) 
06570                                       /* base at 16 */ == 5 && 
06571                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06572                                       /* index at 16 */ && 
06573                                 (MATCH_w_8_16 >> 3 & 0x7) 
06574                                       /* index at 16 */ < 8)) 
06575                                 goto MATCH_label_c1024;  /*opt-block+*/
06576                               else 
06577                                 goto MATCH_label_c1023;  /*opt-block+*/
06578                               
06579                               break;
06580                             case 5: 
06581                               goto MATCH_label_c1025; break;
06582                             default: assert(0);
06583                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06584                         break;
06585                       case 1: 
06586                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06587                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06588                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06589                                 /* index at 16 */ && 
06590                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06591                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06592                           unsigned reg = 
06593                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06594                           nextPC = 4 + MATCH_p; 
06595                           
06596 #line 1417 "frontend/machine/pentium/decoder.m"
06597                           
06598 
06599                                 stmts = instantiate(pc,  "SUBrmod", DIS_REG32, DIS_EADDR32);
06600 
06601                           
06602 
06603                           
06604                           
06605                           
06606                         } /*opt-block*//*opt-block+*/
06607                         else 
06608                           goto MATCH_label_c1023;  /*opt-block+*/
06609                         
06610                         break;
06611                       case 2: 
06612                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06613                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06614                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06615                                 /* index at 16 */ && 
06616                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06617                           goto MATCH_label_c1024;  /*opt-block+*/
06618                         else 
06619                           goto MATCH_label_c1025;  /*opt-block+*/
06620                         
06621                         break;
06622                       case 3: 
06623                         goto MATCH_label_c1022; break;
06624                       default: assert(0);
06625                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06626                   
06627                   break;
06628                 case 4: 
06629                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06630                   { 
06631                     int /* [~128..127] */ i8 = 
06632                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
06633                     nextPC = 2 + MATCH_p; 
06634                     
06635 #line 1726 "frontend/machine/pentium/decoder.m"
06636                     
06637 
06638                             stmts = instantiate(pc,  "SUBiAL", DIS_I8);
06639 
06640                     
06641 
06642                     
06643                     
06644                     
06645                   }
06646                   
06647                   break;
06648                 case 5: 
06649                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
06650                   { 
06651                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
06652                     nextPC = 5 + MATCH_p; 
06653                     
06654 #line 1678 "frontend/machine/pentium/decoder.m"
06655                     
06656 
06657                             stmts = instantiate(pc,  "SUBiEAX", DIS_I32);
06658 
06659                     
06660 
06661                     
06662                     
06663                     
06664                   }
06665                   
06666                   break;
06667                 case 6: 
06668                   nextPC = 1 + MATCH_p; 
06669                   
06670 #line 330 "frontend/machine/pentium/decoder.m"
06671                          // For now, treat seg.cs as a 1 byte NOP
06672 
06673                         stmts = instantiate(pc,  "NOP");
06674 
06675                   
06676 
06677                   
06678                   
06679                   
06680                   
06681                   break;
06682                 case 7: 
06683                   nextPC = 1 + MATCH_p; 
06684                   
06685 #line 1220 "frontend/machine/pentium/decoder.m"
06686                   
06687 
06688                         stmts = instantiate(pc,  "DAS");
06689 
06690                   
06691 
06692                   
06693                   
06694                   
06695                   
06696                   break;
06697                 default: assert(0);
06698               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
06699             break;
06700           case 3: 
06701             
06702               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
06703                 case 0: 
06704                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06705                   
06706                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06707                       case 0: 
06708                         
06709                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06710                             case 0: case 1: case 2: case 3: case 6: case 7: 
06711                               goto MATCH_label_c1026; break;
06712                             case 4: 
06713                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06714                               if ((MATCH_w_8_16 & 0x7) 
06715                                       /* base at 16 */ == 5 && 
06716                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06717                                       /* index at 16 */ && 
06718                                 (MATCH_w_8_16 >> 3 & 0x7) 
06719                                       /* index at 16 */ < 8)) 
06720                                 goto MATCH_label_c1028;  /*opt-block+*/
06721                               else 
06722                                 goto MATCH_label_c1027;  /*opt-block+*/
06723                               
06724                               break;
06725                             case 5: 
06726                               goto MATCH_label_c1029; break;
06727                             default: assert(0);
06728                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06729                         break;
06730                       case 1: 
06731                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06732                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06733                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06734                                 /* index at 16 */ && 
06735                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06736                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06737                           unsigned r8 = 
06738                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06739                           nextPC = 4 + MATCH_p; 
06740                           
06741 #line 1525 "frontend/machine/pentium/decoder.m"
06742                           
06743 
06744                                 stmts = instantiate(pc,  "CMPmrb", DIS_EADDR8, DIS_R8);
06745 
06746                           
06747 
06748                           
06749                           
06750                           
06751                         } /*opt-block*//*opt-block+*/
06752                         else 
06753                           goto MATCH_label_c1027;  /*opt-block+*/
06754                         
06755                         break;
06756                       case 2: 
06757                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06758                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06759                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06760                                 /* index at 16 */ && 
06761                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06762                           goto MATCH_label_c1028;  /*opt-block+*/
06763                         else 
06764                           goto MATCH_label_c1029;  /*opt-block+*/
06765                         
06766                         break;
06767                       case 3: 
06768                         goto MATCH_label_c1026; break;
06769                       default: assert(0);
06770                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06771                   
06772                   break;
06773                 case 1: 
06774                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06775                   
06776                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06777                       case 0: 
06778                         
06779                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06780                             case 0: case 1: case 2: case 3: case 6: case 7: 
06781                               goto MATCH_label_c1030; break;
06782                             case 4: 
06783                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06784                               if ((MATCH_w_8_16 & 0x7) 
06785                                       /* base at 16 */ == 5 && 
06786                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06787                                       /* index at 16 */ && 
06788                                 (MATCH_w_8_16 >> 3 & 0x7) 
06789                                       /* index at 16 */ < 8)) 
06790                                 goto MATCH_label_c1032;  /*opt-block+*/
06791                               else 
06792                                 goto MATCH_label_c1031;  /*opt-block+*/
06793                               
06794                               break;
06795                             case 5: 
06796                               goto MATCH_label_c1033; break;
06797                             default: assert(0);
06798                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06799                         break;
06800                       case 1: 
06801                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06802                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06803                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06804                                 /* index at 16 */ && 
06805                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06806                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06807                           unsigned reg = 
06808                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06809                           nextPC = 4 + MATCH_p; 
06810                           
06811 #line 1477 "frontend/machine/pentium/decoder.m"
06812                           
06813 
06814                                 stmts = instantiate(pc,  "CMPmrod", DIS_EADDR32, DIS_REG32);
06815 
06816                           
06817 
06818                           
06819                           
06820                           
06821                         } /*opt-block*//*opt-block+*/
06822                         else 
06823                           goto MATCH_label_c1031;  /*opt-block+*/
06824                         
06825                         break;
06826                       case 2: 
06827                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06828                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06829                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06830                                 /* index at 16 */ && 
06831                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06832                           goto MATCH_label_c1032;  /*opt-block+*/
06833                         else 
06834                           goto MATCH_label_c1033;  /*opt-block+*/
06835                         
06836                         break;
06837                       case 3: 
06838                         goto MATCH_label_c1030; break;
06839                       default: assert(0);
06840                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06841                   
06842                   break;
06843                 case 2: 
06844                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06845                   
06846                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06847                       case 0: 
06848                         
06849                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06850                             case 0: case 1: case 2: case 3: case 6: case 7: 
06851                               goto MATCH_label_c1034; break;
06852                             case 4: 
06853                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06854                               if ((MATCH_w_8_16 & 0x7) 
06855                                       /* base at 16 */ == 5 && 
06856                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06857                                       /* index at 16 */ && 
06858                                 (MATCH_w_8_16 >> 3 & 0x7) 
06859                                       /* index at 16 */ < 8)) 
06860                                 goto MATCH_label_c1036;  /*opt-block+*/
06861                               else 
06862                                 goto MATCH_label_c1035;  /*opt-block+*/
06863                               
06864                               break;
06865                             case 5: 
06866                               goto MATCH_label_c1037; break;
06867                             default: assert(0);
06868                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06869                         break;
06870                       case 1: 
06871                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06872                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06873                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06874                                 /* index at 16 */ && 
06875                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06876                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06877                           unsigned r8 = 
06878                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06879                           nextPC = 4 + MATCH_p; 
06880                           
06881 #line 1453 "frontend/machine/pentium/decoder.m"
06882                           
06883 
06884                                 stmts = instantiate(pc,  "CMPrmb", DIS_R8, DIS_EADDR8);
06885 
06886                           
06887 
06888                           
06889                           
06890                           
06891                         } /*opt-block*//*opt-block+*/
06892                         else 
06893                           goto MATCH_label_c1035;  /*opt-block+*/
06894                         
06895                         break;
06896                       case 2: 
06897                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06898                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06899                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06900                                 /* index at 16 */ && 
06901                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06902                           goto MATCH_label_c1036;  /*opt-block+*/
06903                         else 
06904                           goto MATCH_label_c1037;  /*opt-block+*/
06905                         
06906                         break;
06907                       case 3: 
06908                         goto MATCH_label_c1034; break;
06909                       default: assert(0);
06910                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06911                   
06912                   break;
06913                 case 3: 
06914                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06915                   
06916                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06917                       case 0: 
06918                         
06919                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06920                             case 0: case 1: case 2: case 3: case 6: case 7: 
06921                               goto MATCH_label_c1038; break;
06922                             case 4: 
06923                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06924                               if ((MATCH_w_8_16 & 0x7) 
06925                                       /* base at 16 */ == 5 && 
06926                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06927                                       /* index at 16 */ && 
06928                                 (MATCH_w_8_16 >> 3 & 0x7) 
06929                                       /* index at 16 */ < 8)) 
06930                                 goto MATCH_label_c1040;  /*opt-block+*/
06931                               else 
06932                                 goto MATCH_label_c1039;  /*opt-block+*/
06933                               
06934                               break;
06935                             case 5: 
06936                               goto MATCH_label_c1041; break;
06937                             default: assert(0);
06938                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06939                         break;
06940                       case 1: 
06941                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06942                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06943                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06944                                 /* index at 16 */ && 
06945                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06946                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06947                           unsigned reg = 
06948                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06949                           nextPC = 4 + MATCH_p; 
06950                           
06951 #line 1405 "frontend/machine/pentium/decoder.m"
06952                           
06953 
06954                                 stmts = instantiate(pc,  "CMPrmod", DIS_REG32, DIS_EADDR32);
06955 
06956                           
06957 
06958                           
06959                           
06960                           
06961                         } /*opt-block*//*opt-block+*/
06962                         else 
06963                           goto MATCH_label_c1039;  /*opt-block+*/
06964                         
06965                         break;
06966                       case 2: 
06967                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06968                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06969                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06970                                 /* index at 16 */ && 
06971                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06972                           goto MATCH_label_c1040;  /*opt-block+*/
06973                         else 
06974                           goto MATCH_label_c1041;  /*opt-block+*/
06975                         
06976                         break;
06977                       case 3: 
06978                         goto MATCH_label_c1038; break;
06979                       default: assert(0);
06980                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06981                   
06982                   break;
06983                 case 4: 
06984                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06985                   { 
06986                     int /* [~128..127] */ i8 = 
06987                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
06988                     nextPC = 2 + MATCH_p; 
06989                     
06990 #line 1720 "frontend/machine/pentium/decoder.m"
06991                     
06992 
06993                             stmts = instantiate(pc,  "CMPiAL", DIS_I8);
06994 
06995                     
06996 
06997                     
06998                     
06999                     
07000                   }
07001                   
07002                   break;
07003                 case 5: 
07004                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
07005                   { 
07006                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
07007                     nextPC = 5 + MATCH_p; 
07008                     
07009 #line 1672 "frontend/machine/pentium/decoder.m"
07010                     
07011 
07012                             stmts = instantiate(pc,  "CMPiEAX", DIS_I32);
07013 
07014                     
07015 
07016                     
07017                     
07018                     
07019                   }
07020                   
07021                   break;
07022                 case 6: 
07023                   nextPC = 1 + MATCH_p; 
07024                   
07025 #line 333 "frontend/machine/pentium/decoder.m"
07026                          // For now, treat seg.ds as a 1 byte NOP
07027 
07028                         stmts = instantiate(pc,  "NOP");
07029 
07030                   
07031 
07032                   
07033                   
07034                   
07035                   
07036                   break;
07037                 case 7: 
07038                   goto MATCH_label_c64; break;
07039                 default: assert(0);
07040               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
07041             break;
07042           case 4: 
07043             { 
07044               unsigned r32 = (MATCH_w_8_0 & 0x7) /* r32 at 0 */;
07045               nextPC = 1 + MATCH_p; 
07046               
07047 #line 1205 "frontend/machine/pentium/decoder.m"
07048               
07049 
07050                     stmts = instantiate(pc,  "DECod", DIS_R32);
07051 
07052               
07053 
07054               
07055               
07056               
07057             }
07058             
07059             break;
07060           case 5: 
07061             { 
07062               unsigned r32 = (MATCH_w_8_0 & 0x7) /* r32 at 0 */;
07063               nextPC = 1 + MATCH_p; 
07064               
07065 #line 871 "frontend/machine/pentium/decoder.m"
07066               
07067 
07068                     stmts = instantiate(pc,  "POPod", DIS_R32);
07069 
07070               
07071 
07072               
07073               
07074               
07075             }
07076             
07077             break;
07078           case 6: 
07079             
07080               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
07081                 case 0: 
07082                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
07083                   { 
07084                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
07085                     nextPC = 5 + MATCH_p; 
07086                     
07087 #line 820 "frontend/machine/pentium/decoder.m"
07088                     
07089 
07090                             stmts = instantiate(pc,  "PUSH.Ivod", DIS_I32);
07091 
07092                     
07093 
07094                     
07095                     
07096                     
07097                   }
07098                   
07099                   break;
07100                 case 1: 
07101                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
07102                   
07103                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
07104                       case 0: 
07105                         
07106                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
07107                             case 0: case 1: case 2: case 3: case 6: case 7: 
07108                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
07109                               goto MATCH_label_c1042; 
07110                               
07111                               break;
07112                             case 4: 
07113                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
07114                               if ((MATCH_w_8_16 & 0x7) 
07115                                       /* base at 16 */ == 5 && 
07116                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07117                                       /* index at 16 */ && 
07118                                 (MATCH_w_8_16 >> 3 & 0x7) 
07119                                       /* index at 16 */ < 8)) { 
07120                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
07121                                 goto MATCH_label_c1044; 
07122                                 
07123                               } /*opt-block*/
07124                               else { 
07125                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
07126                                 goto MATCH_label_c1043; 
07127                                 
07128                               } /*opt-block*/
07129                               
07130                               break;
07131                             case 5: 
07132                               MATCH_w_32_48 = getDword(6 + MATCH_p); 
07133                               goto MATCH_label_c1045; 
07134                               
07135                               break;
07136                             default: assert(0);
07137                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
07138                         break;
07139                       case 1: 
07140                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
07141                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
07142                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07143                                 /* index at 16 */ && 
07144                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
07145                           MATCH_w_32_32 = getDword(4 + MATCH_p); 
07146                           { 
07147                             unsigned Eaddr = 1 + addressToPC(MATCH_p);
07148                             unsigned i32 = MATCH_w_32_32 /* i32 at 32 */;
07149                             unsigned reg = 
07150                               (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
07151                             nextPC = 8 + MATCH_p; 
07152                             
07153 #line 1154 "frontend/machine/pentium/decoder.m"
07154                             
07155 
07156                                     stmts = instantiate(pc,  "IMUL.Ivd", DIS_REG32, DIS_EADDR32, DIS_I32);
07157 
07158                             
07159 
07160                             
07161                             
07162                             
07163                           }
07164                           
07165                         } /*opt-block*/
07166                         else { 
07167                           MATCH_w_32_24 = getDword(3 + MATCH_p); 
07168                           goto MATCH_label_c1043; 
07169                           
07170                         } /*opt-block*/
07171                         
07172                         break;
07173                       case 2: 
07174                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
07175                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
07176                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07177                                 /* index at 16 */ && 
07178                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
07179                           MATCH_w_32_56 = getDword(7 + MATCH_p); 
07180                           goto MATCH_label_c1044; 
07181                           
07182                         } /*opt-block*/
07183                         else { 
07184                           MATCH_w_32_48 = getDword(6 + MATCH_p); 
07185                           goto MATCH_label_c1045; 
07186                           
07187                         } /*opt-block*/
07188                         
07189                         break;
07190                       case 3: 
07191                         MATCH_w_32_16 = getDword(2 + MATCH_p); 
07192                         goto MATCH_label_c1042; 
07193                         
07194                         break;
07195                       default: assert(0);
07196                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
07197                   
07198                   break;
07199                 case 2: 
07200                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
07201                   { 
07202                     int /* [~128..127] */ i8 = 
07203                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
07204                     nextPC = 2 + MATCH_p; 
07205                     
07206 #line 826 "frontend/machine/pentium/decoder.m"
07207                     
07208 
07209                             stmts = instantiate(pc,  "PUSH.Ixob", DIS_I8);
07210 
07211                     
07212 
07213                     
07214                     
07215                     
07216                   }
07217                   
07218                   break;
07219                 case 3: 
07220                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
07221                   
07222                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
07223                       case 0: 
07224                         
07225                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
07226                             case 0: case 1: case 2: case 3: case 6: case 7: 
07227                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
07228                               goto MATCH_label_c1046; 
07229                               
07230                               break;
07231                             case 4: 
07232                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
07233                               if ((MATCH_w_8_16 & 0x7) 
07234                                       /* base at 16 */ == 5 && 
07235                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07236                                       /* index at 16 */ && 
07237                                 (MATCH_w_8_16 >> 3 & 0x7) 
07238                                       /* index at 16 */ < 8)) { 
07239                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
07240                                 goto MATCH_label_c1048; 
07241                                 
07242                               } /*opt-block*/
07243                               else { 
07244                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
07245                                 goto MATCH_label_c1047; 
07246                                 
07247                               } /*opt-block*/
07248                               
07249                               break;
07250                             case 5: 
07251                               MATCH_w_8_48 = getByte(6 + MATCH_p); 
07252                               goto MATCH_label_c1049; 
07253                               
07254                               break;
07255                             default: assert(0);
07256                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
07257                         break;
07258                       case 1: 
07259                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
07260                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
07261                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07262                                 /* index at 16 */ && 
07263                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
07264                           MATCH_w_8_32 = getByte(4 + MATCH_p); 
07265                           { 
07266                             unsigned Eaddr = 1 + addressToPC(MATCH_p);
07267                             int /* [~128..127] */ i8 = 
07268                               sign_extend((MATCH_w_8_32 & 0xff) 
07269                                                 /* i8 at 32 */, 8);
07270                             unsigned reg = 
07271                               (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
07272                             nextPC = 5 + MATCH_p; 
07273                             
07274 #line 1160 "frontend/machine/pentium/decoder.m"
07275                             
07276 
07277                                     stmts = instantiate(pc,  "IMUL.Ibod", DIS_REG32, DIS_EADDR32, DIS_I8);
07278 
07279                             
07280 
07281                             
07282                             
07283                             
07284                           }
07285                           
07286                         } /*opt-block*/
07287                         else { 
07288                           MATCH_w_8_24 = getByte(3 + MATCH_p); 
07289                           goto MATCH_label_c1047; 
07290                           
07291                         } /*opt-block*/
07292                         
07293                         break;
07294                       case 2: 
07295                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
07296                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
07297                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07298                                 /* index at 16 */ && 
07299                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
07300                           MATCH_w_8_56 = getByte(7 + MATCH_p); 
07301                           goto MATCH_label_c1048; 
07302                           
07303                         } /*opt-block*/
07304                         else { 
07305                           MATCH_w_8_48 = getByte(6 + MATCH_p); 
07306                           goto MATCH_label_c1049; 
07307                           
07308                         } /*opt-block*/
07309                         
07310                         break;
07311                       case 3: 
07312                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
07313                         goto MATCH_label_c1046; 
07314                         
07315                         break;
07316                       default: assert(0);
07317                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
07318                   
07319                   break;
07320                 case 4: case 5: case 6: case 7: 
07321                   goto MATCH_label_c64; break;
07322                 default: assert(0);
07323               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
07324             break;
07325           case 7: 
07326             
07327               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
07328                 case 0: 
07329                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
07330                   { 
07331                     unsigned relocd = 
07332                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
07333                                   8) + addressToPC(MATCH_p);
07334                     nextPC = 2 + MATCH_p; 
07335                     
07336 #line 174 "frontend/machine/pentium/decoder.m"
07337                     
07338 
07339                             COND_JUMP("Jb.S", 2, relocd, BRANCH_JMI)
07340 
07341                     
07342                     
07343                     
07344                   }
07345                   
07346                   break;
07347                 case 1: 
07348                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
07349                   { 
07350                     unsigned relocd = 
07351                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
07352                                   8) + addressToPC(MATCH_p);
07353                     nextPC = 2 + MATCH_p; 
07354                     
07355 #line 172 "frontend/machine/pentium/decoder.m"
07356                     
07357 
07358                             COND_JUMP("Jb.NS", 2, relocd, BRANCH_JPOS)
07359 
07360                     
07361                     
07362                     
07363                   }
07364                   
07365                   break;
07366                 case 2: 
07367                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
07368                   { 
07369                     unsigned relocd = 
07370                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
07371                                   8) + addressToPC(MATCH_p);
07372                     nextPC = 2 + MATCH_p; 
07373                     
07374 #line 170 "frontend/machine/pentium/decoder.m"
07375                     
07376 
07377                             COND_JUMP("Jb.P", 2, relocd, BRANCH_JPAR)
07378 
07379                     
07380                     
07381                     
07382                   }
07383                   
07384                   break;
07385                 case 3: 
07386                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
07387                   { 
07388                     unsigned relocd = 
07389                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
07390                                   8) + addressToPC(MATCH_p);
07391                     nextPC = 2 + MATCH_p; 
07392                     
07393 #line 168 "frontend/machine/pentium/decoder.m"
07394                     
07395 
07396                             COND_JUMP("Jb.NP", 2, relocd, (BRANCH_TYPE)0)
07397 
07398                     
07399                     
07400                     
07401                   }
07402                   
07403                   break;
07404                 case 4: 
07405                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
07406                   { 
07407                     unsigned relocd = 
07408                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
07409                                   8) + addressToPC(MATCH_p);
07410                     nextPC = 2 + MATCH_p; 
07411                     
07412 #line 166 "frontend/machine/pentium/decoder.m"
07413                     
07414 
07415                             COND_JUMP("Jb.L", 2, relocd, BRANCH_JSL)
07416 
07417                     
07418                     
07419                     
07420                   }
07421                   
07422                   break;
07423                 case 5: 
07424                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
07425                   { 
07426                     unsigned relocd = 
07427                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
07428                                   8) + addressToPC(MATCH_p);
07429                     nextPC = 2 + MATCH_p; 
07430                     
07431 #line 164 "frontend/machine/pentium/decoder.m"
07432                     
07433 
07434                             COND_JUMP("Jb.NL", 2, relocd, BRANCH_JSGE)
07435 
07436                     
07437                     
07438                     
07439                   }
07440                   
07441                   break;
07442                 case 6: 
07443                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
07444                   { 
07445                     unsigned relocd = 
07446                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
07447                                   8) + addressToPC(MATCH_p);
07448                     nextPC = 2 + MATCH_p; 
07449                     
07450 #line 162 "frontend/machine/pentium/decoder.m"
07451                     
07452 
07453                             COND_JUMP("Jb.LE", 2, relocd, BRANCH_JSLE)
07454 
07455                     
07456                     
07457                     
07458                   }
07459                   
07460                   break;
07461                 case 7: 
07462                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
07463                   { 
07464                     unsigned relocd = 
07465                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
07466                                   8) + addressToPC(MATCH_p);
07467                     nextPC = 2 + MATCH_p; 
07468                     
07469 #line 160 "frontend/machine/pentium/decoder.m"
07470                     
07471 
07472                             COND_JUMP("Jb.NLE", 2, relocd, BRANCH_JSG)
07473 
07474                     
07475                     
07476                     
07477                   }
07478                   
07479                   break;
07480                 default: assert(0);
07481               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
07482             break;
07483           case 8: 
07484             
07485               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
07486                 case 0: 
07487                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
07488                   
07489                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
07490                       case 0: 
07491                         
07492                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
07493                             case 0: case 1: case 2: case 3: case 6: case 7: 
07494                               goto MATCH_label_c1050; break;
07495                             case 4: 
07496                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
07497                               if ((MATCH_w_8_16 & 0x7) 
07498                                       /* base at 16 */ == 5 && 
07499                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07500                                       /* index at 16 */ && 
07501                                 (MATCH_w_8_16 >> 3 & 0x7) 
07502                                       /* index at 16 */ < 8)) 
07503                                 goto MATCH_label_c1052;  /*opt-block+*/
07504                               else 
07505                                 goto MATCH_label_c1051;  /*opt-block+*/
07506                               
07507                               break;
07508                             case 5: 
07509                               goto MATCH_label_c1053; break;
07510                             default: assert(0);
07511                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
07512                         break;
07513                       case 1: 
07514                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
07515                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
07516                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07517                                 /* index at 16 */ && 
07518                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
07519                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
07520                           unsigned reg = 
07521                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
07522                           nextPC = 4 + MATCH_p; 
07523                           
07524 #line 1037 "frontend/machine/pentium/decoder.m"
07525                           
07526 
07527                                 stmts = instantiate(pc,  "MOVmrb", DIS_EADDR8, DIS_REG8);
07528 
07529                           
07530 
07531                           
07532                           
07533                           
07534                         } /*opt-block*//*opt-block+*/
07535                         else 
07536                           goto MATCH_label_c1051;  /*opt-block+*/
07537                         
07538                         break;
07539                       case 2: 
07540                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
07541                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
07542                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07543                                 /* index at 16 */ && 
07544                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
07545                           goto MATCH_label_c1052;  /*opt-block+*/
07546                         else 
07547                           goto MATCH_label_c1053;  /*opt-block+*/
07548                         
07549                         break;
07550                       case 3: 
07551                         goto MATCH_label_c1050; break;
07552                       default: assert(0);
07553                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
07554                   
07555                   break;
07556                 case 1: 
07557                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
07558                   
07559                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
07560                       case 0: 
07561                         
07562                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
07563                             case 0: case 1: case 2: case 3: case 6: case 7: 
07564                               goto MATCH_label_c1054; break;
07565                             case 4: 
07566                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
07567                               if ((MATCH_w_8_16 & 0x7) 
07568                                       /* base at 16 */ == 5 && 
07569                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07570                                       /* index at 16 */ && 
07571                                 (MATCH_w_8_16 >> 3 & 0x7) 
07572                                       /* index at 16 */ < 8)) 
07573                                 goto MATCH_label_c1056;  /*opt-block+*/
07574                               else 
07575                                 goto MATCH_label_c1055;  /*opt-block+*/
07576                               
07577                               break;
07578                             case 5: 
07579                               goto MATCH_label_c1057; break;
07580                             default: assert(0);
07581                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
07582                         break;
07583                       case 1: 
07584                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
07585                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
07586                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07587                                 /* index at 16 */ && 
07588                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
07589                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
07590                           unsigned reg = 
07591                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
07592                           nextPC = 4 + MATCH_p; 
07593                           
07594 #line 1031 "frontend/machine/pentium/decoder.m"
07595                           
07596 
07597                                 stmts = instantiate(pc,  "MOVmrod", DIS_EADDR32, DIS_REG32);
07598 
07599                           
07600 
07601                           
07602                           
07603                           
07604                         } /*opt-block*//*opt-block+*/
07605                         else 
07606                           goto MATCH_label_c1055;  /*opt-block+*/
07607                         
07608                         break;
07609                       case 2: 
07610                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
07611                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
07612                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07613                                 /* index at 16 */ && 
07614                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
07615                           goto MATCH_label_c1056;  /*opt-block+*/
07616                         else 
07617                           goto MATCH_label_c1057;  /*opt-block+*/
07618                         
07619                         break;
07620                       case 3: 
07621                         goto MATCH_label_c1054; break;
07622                       default: assert(0);
07623                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
07624                   
07625                   break;
07626                 case 2: 
07627                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
07628                   
07629                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
07630                       case 0: 
07631                         
07632                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
07633                             case 0: case 1: case 2: case 3: case 6: case 7: 
07634                               goto MATCH_label_c1058; break;
07635                             case 4: 
07636                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
07637                               if ((MATCH_w_8_16 & 0x7) 
07638                                       /* base at 16 */ == 5 && 
07639                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07640                                       /* index at 16 */ && 
07641                                 (MATCH_w_8_16 >> 3 & 0x7) 
07642                                       /* index at 16 */ < 8)) 
07643                                 goto MATCH_label_c1060;  /*opt-block+*/
07644                               else 
07645                                 goto MATCH_label_c1059;  /*opt-block+*/
07646                               
07647                               break;
07648                             case 5: 
07649                               goto MATCH_label_c1061; break;
07650                             default: assert(0);
07651                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
07652                         break;
07653                       case 1: 
07654                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
07655                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
07656                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07657                                 /* index at 16 */ && 
07658                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
07659                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
07660                           unsigned reg = 
07661                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
07662                           nextPC = 4 + MATCH_p; 
07663                           
07664 #line 1028 "frontend/machine/pentium/decoder.m"
07665                           
07666 
07667                                 stmts = instantiate(pc,  "MOVrmb", DIS_REG8, DIS_EADDR8);
07668 
07669                           
07670 
07671                           
07672                           
07673                           
07674                         } /*opt-block*//*opt-block+*/
07675                         else 
07676                           goto MATCH_label_c1059;  /*opt-block+*/
07677                         
07678                         break;
07679                       case 2: 
07680                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
07681                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
07682                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07683                                 /* index at 16 */ && 
07684                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
07685                           goto MATCH_label_c1060;  /*opt-block+*/
07686                         else 
07687                           goto MATCH_label_c1061;  /*opt-block+*/
07688                         
07689                         break;
07690                       case 3: 
07691                         goto MATCH_label_c1058; break;
07692                       default: assert(0);
07693                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
07694                   
07695                   break;
07696                 case 3: 
07697                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
07698                   
07699                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
07700                       case 0: 
07701                         
07702                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
07703                             case 0: case 1: case 2: case 3: case 6: case 7: 
07704                               goto MATCH_label_c1062; break;
07705                             case 4: 
07706                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
07707                               if ((MATCH_w_8_16 & 0x7) 
07708                                       /* base at 16 */ == 5 && 
07709                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07710                                       /* index at 16 */ && 
07711                                 (MATCH_w_8_16 >> 3 & 0x7) 
07712                                       /* index at 16 */ < 8)) 
07713                                 goto MATCH_label_c1064;  /*opt-block+*/
07714                               else 
07715                                 goto MATCH_label_c1063;  /*opt-block+*/
07716                               
07717                               break;
07718                             case 5: 
07719                               goto MATCH_label_c1065; break;
07720                             default: assert(0);
07721                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
07722                         break;
07723                       case 1: 
07724                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
07725                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
07726                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07727                                 /* index at 16 */ && 
07728                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
07729                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
07730                           unsigned reg = 
07731                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
07732                           nextPC = 4 + MATCH_p; 
07733                           
07734 #line 1022 "frontend/machine/pentium/decoder.m"
07735                           
07736 
07737                                 stmts = instantiate(pc,  "MOVrmod", DIS_REG32, DIS_EADDR32);
07738 
07739                           
07740 
07741                           
07742                           
07743                           
07744                         } /*opt-block*//*opt-block+*/
07745                         else 
07746                           goto MATCH_label_c1063;  /*opt-block+*/
07747                         
07748                         break;
07749                       case 2: 
07750                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
07751                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
07752                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07753                                 /* index at 16 */ && 
07754                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
07755                           goto MATCH_label_c1064;  /*opt-block+*/
07756                         else 
07757                           goto MATCH_label_c1065;  /*opt-block+*/
07758                         
07759                         break;
07760                       case 3: 
07761                         goto MATCH_label_c1062; break;
07762                       default: assert(0);
07763                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
07764                   
07765                   break;
07766                 case 4: case 6: 
07767                   goto MATCH_label_c64; break;
07768                 case 5: 
07769                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
07770                   
07771                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
07772                       case 0: 
07773                         
07774                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
07775                             case 0: case 1: case 2: case 3: case 6: case 7: 
07776                               { 
07777                                 unsigned Mem = 1 + addressToPC(MATCH_p);
07778                                 unsigned reg = 
07779                                   (MATCH_w_8_8 >> 3 & 0x7) 
07780                                         /* reg_opcode at 8 */;
07781                                 nextPC = 2 + MATCH_p; 
07782                                 
07783 #line 1073 "frontend/machine/pentium/decoder.m"
07784                                 
07785 
07786                                         stmts = instantiate(pc,  "LEA.od", DIS_REG32, DIS_MEM);
07787 
07788                                 
07789 
07790                                 
07791                                 
07792                                 
07793                               }
07794                               
07795                               break;
07796                             case 4: 
07797                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
07798                               if ((MATCH_w_8_16 & 0x7) 
07799                                       /* base at 16 */ == 5 && 
07800                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07801                                       /* index at 16 */ && 
07802                                 (MATCH_w_8_16 >> 3 & 0x7) 
07803                                       /* index at 16 */ < 8)) 
07804                                 goto MATCH_label_c1067;  /*opt-block+*/
07805                               else 
07806                                 goto MATCH_label_c1066;  /*opt-block+*/
07807                               
07808                               break;
07809                             case 5: 
07810                               goto MATCH_label_c1068; break;
07811                             default: assert(0);
07812                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
07813                         break;
07814                       case 1: 
07815                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
07816                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
07817                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07818                                 /* index at 16 */ && 
07819                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
07820                           unsigned Mem = 1 + addressToPC(MATCH_p);
07821                           unsigned reg = 
07822                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
07823                           nextPC = 4 + MATCH_p; 
07824                           
07825 #line 1073 "frontend/machine/pentium/decoder.m"
07826                           
07827 
07828                                 stmts = instantiate(pc,  "LEA.od", DIS_REG32, DIS_MEM);
07829 
07830                           
07831 
07832                           
07833                           
07834                           
07835                         } /*opt-block*//*opt-block+*/
07836                         else 
07837                           goto MATCH_label_c1066;  /*opt-block+*/
07838                         
07839                         break;
07840                       case 2: 
07841                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
07842                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
07843                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07844                                 /* index at 16 */ && 
07845                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
07846                           goto MATCH_label_c1067;  /*opt-block+*/
07847                         else 
07848                           goto MATCH_label_c1068;  /*opt-block+*/
07849                         
07850                         break;
07851                       case 3: 
07852                         goto MATCH_label_c64; break;
07853                       default: assert(0);
07854                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
07855                   
07856                   break;
07857                 case 7: 
07858                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
07859                   if ((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */ == 0) 
07860                     
07861                       switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
07862                         case 0: 
07863                           
07864                             switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
07865                               case 0: case 1: case 2: case 3: case 6: case 7: 
07866                                 goto MATCH_label_c1069; break;
07867                               case 4: 
07868                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
07869                                 if ((MATCH_w_8_16 & 0x7) 
07870                                         /* base at 16 */ == 5 && 
07871                                   (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07872                                         /* index at 16 */ && 
07873                                   (MATCH_w_8_16 >> 3 & 0x7) 
07874                                         /* index at 16 */ < 8)) 
07875                                   goto MATCH_label_c1071;  /*opt-block+*/
07876                                 else 
07877                                   goto MATCH_label_c1070;  /*opt-block+*/
07878                                 
07879                                 break;
07880                               case 5: 
07881                                 goto MATCH_label_c1072; break;
07882                               default: assert(0);
07883                             } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
07884                           break;
07885                         case 1: 
07886                           MATCH_w_8_16 = getByte(2 + MATCH_p); 
07887                           if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
07888                             (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07889                                   /* index at 16 */ && 
07890                             (MATCH_w_8_16 >> 3 & 0x7) 
07891                                   /* index at 16 */ < 8)) { 
07892                             unsigned Eaddr = 1 + addressToPC(MATCH_p);
07893                             nextPC = 4 + MATCH_p; 
07894                             
07895 #line 877 "frontend/machine/pentium/decoder.m"
07896                             
07897 
07898                                     stmts = instantiate(pc,  "POP.Evod", DIS_EADDR32);
07899 
07900                             
07901 
07902                             
07903                             
07904                             
07905                           } /*opt-block*//*opt-block+*/
07906                           else 
07907                             goto MATCH_label_c1070;  /*opt-block+*/
07908                           
07909                           break;
07910                         case 2: 
07911                           MATCH_w_8_16 = getByte(2 + MATCH_p); 
07912                           if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
07913                             (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
07914                                   /* index at 16 */ && 
07915                             (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
07916                             goto MATCH_label_c1071;  /*opt-block+*/
07917                           else 
07918                             goto MATCH_label_c1072;  /*opt-block+*/
07919                           
07920                           break;
07921                         case 3: 
07922                           goto MATCH_label_c1069; break;
07923                         default: assert(0);
07924                       } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/  
07925                   else 
07926                     goto MATCH_label_c64;  /*opt-block+*/
07927                   
07928                   break;
07929                 default: assert(0);
07930               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
07931             break;
07932           case 9: 
07933             
07934               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
07935                 case 0: 
07936                   nextPC = 1 + MATCH_p; 
07937                   
07938 #line 1271 "frontend/machine/pentium/decoder.m"
07939                   
07940 
07941                         stmts = instantiate(pc,  "CWDE");
07942 
07943                   
07944 
07945                   
07946                   
07947                   
07948                   
07949                   break;
07950                 case 1: 
07951                   nextPC = 1 + MATCH_p; 
07952                   
07953 #line 1226 "frontend/machine/pentium/decoder.m"
07954                   
07955 
07956                         stmts = instantiate(pc,  "CDQ");
07957 
07958                   
07959 
07960                   
07961                   
07962                   
07963                   
07964                   break;
07965                 case 2: 
07966                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
07967                   MATCH_w_16_40 = getWord(5 + MATCH_p); 
07968                   { 
07969                     unsigned off = MATCH_w_32_8 /* i32 at 8 */;
07970                     unsigned seg = (MATCH_w_16_40 & 0xffff) /* i16 at 40 */;
07971                     nextPC = 7 + MATCH_p; 
07972                     
07973 #line 1279 "frontend/machine/pentium/decoder.m"
07974                     
07975 
07976                             unused(seg); unused(off);
07977 
07978                             stmts = instantiate(pc, "NOP");
07979 
07980                     
07981 
07982                     
07983                     
07984                     
07985                   }
07986                   
07987                   break;
07988                 case 3: 
07989                   nextPC = 1 + MATCH_p; 
07990                   
07991 #line 369 "frontend/machine/pentium/decoder.m"
07992                   
07993 
07994                         stmts = instantiate(pc,  "WAIT");
07995 
07996                   
07997 
07998                   
07999                   
08000                   
08001                   
08002                   break;
08003                 case 4: case 5: 
08004                   goto MATCH_label_c64; break;
08005                 case 6: 
08006                   nextPC = 1 + MATCH_p; 
08007                   
08008 #line 472 "frontend/machine/pentium/decoder.m"
08009                   
08010 
08011                         stmts = instantiate(pc,  "SAHF");
08012 
08013                   
08014 
08015                   
08016                   
08017                   
08018                   
08019                   break;
08020                 case 7: 
08021                   nextPC = 1 + MATCH_p; 
08022                   
08023 #line 1088 "frontend/machine/pentium/decoder.m"
08024                   
08025 
08026                         stmts = instantiate(pc,  "LAHF");
08027 
08028                   
08029 
08030                     /* Branches have been handled in decodeInstruction() now */
08031 
08032                   
08033                   
08034                   
08035                   
08036                   break;
08037                 default: assert(0);
08038               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
08039             break;
08040           case 10: 
08041             
08042               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
08043                 case 0: 
08044                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
08045                   { 
08046                     unsigned i8 = (MATCH_w_8_8 & 0xff) /* i8 at 8 */;
08047                     nextPC = 2 + MATCH_p; 
08048                     
08049 #line 402 "frontend/machine/pentium/decoder.m"
08050                     
08051 
08052                             stmts = instantiate(pc,  "TEST.AL.Ib", DIS_I8);
08053 
08054                     
08055 
08056                     
08057                     
08058                     
08059                   }
08060                   
08061                   break;
08062                 case 1: 
08063                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
08064                   { 
08065                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
08066                     nextPC = 5 + MATCH_p; 
08067                     
08068 #line 396 "frontend/machine/pentium/decoder.m"
08069                     
08070 
08071                             stmts = instantiate(pc,  "TEST.eAX.Ivod", DIS_I32);
08072 
08073                     
08074 
08075                     
08076                     
08077                     
08078                   }
08079                   
08080                   break;
08081                 case 2: 
08082                   nextPC = 1 + MATCH_p; 
08083                   
08084 #line 414 "frontend/machine/pentium/decoder.m"
08085                   
08086 
08087                         stmts = instantiate(pc,  "STOSB");
08088 
08089                   
08090 
08091                   
08092                   
08093                   
08094                   
08095                   break;
08096                 case 3: 
08097                   nextPC = 1 + MATCH_p; 
08098                   
08099 #line 408 "frontend/machine/pentium/decoder.m"
08100                   
08101 
08102                         stmts = instantiate(pc,  "STOSvod");
08103 
08104                   
08105 
08106                   
08107                   
08108                   
08109                   
08110                   break;
08111                 case 4: 
08112                   nextPC = 1 + MATCH_p; 
08113                   
08114 #line 1750 "frontend/machine/pentium/decoder.m"
08115                   
08116 
08117                         stmts = instantiate(pc,  "LODSB");
08118 
08119                   
08120 
08121                     /* Floating point instructions */
08122 
08123                   
08124                   
08125                   
08126                   
08127                   break;
08128                 case 5: 
08129                   nextPC = 1 + MATCH_p; 
08130                   
08131 #line 1744 "frontend/machine/pentium/decoder.m"
08132                   
08133 
08134                         stmts = instantiate(pc,  "LODSvod");
08135 
08136                   
08137 
08138                   
08139                   
08140                   
08141                   
08142                   break;
08143                 case 6: 
08144                   nextPC = 1 + MATCH_p; 
08145                   
08146 #line 469 "frontend/machine/pentium/decoder.m"
08147                   
08148 
08149                         stmts = instantiate(pc,  "SCASB");
08150 
08151                   
08152 
08153                   
08154                   
08155                   
08156                   
08157                   break;
08158                 case 7: 
08159                   nextPC = 1 + MATCH_p; 
08160                   
08161 #line 463 "frontend/machine/pentium/decoder.m"
08162                   
08163 
08164                         stmts = instantiate(pc,  "SCASvod");
08165 
08166                   
08167 
08168                   
08169                   
08170                   
08171                   
08172                   break;
08173                 default: assert(0);
08174               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
08175             break;
08176           case 11: 
08177             MATCH_w_32_8 = getDword(1 + MATCH_p); 
08178             { 
08179               unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
08180               unsigned r32 = (MATCH_w_8_0 & 0x7) /* r32 at 0 */;
08181               nextPC = 5 + MATCH_p; 
08182               
08183 #line 989 "frontend/machine/pentium/decoder.m"
08184               
08185 
08186                     stmts = instantiate(pc,  "MOVid", DIS_R32, DIS_I32);
08187 
08188               
08189 
08190               
08191               
08192               
08193             }
08194             
08195             break;
08196           case 12: 
08197             
08198               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
08199                 case 0: 
08200                   MATCH_w_16_8 = getWord(1 + MATCH_p); 
08201                   MATCH_w_8_24 = getByte(3 + MATCH_p); 
08202                   { 
08203                     unsigned i16 = (MATCH_w_16_8 & 0xffff) /* i16 at 8 */;
08204                     int /* [~128..127] */ i8 = 
08205                       sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
08206                     nextPC = 4 + MATCH_p; 
08207                     
08208 #line 1193 "frontend/machine/pentium/decoder.m"
08209                     
08210 
08211                             stmts = instantiate(pc,  "ENTER", DIS_I16, DIS_I8);
08212 
08213                     
08214 
08215                     
08216                     
08217                     
08218                   }
08219                   
08220                   break;
08221                 case 1: 
08222                   nextPC = 1 + MATCH_p; 
08223                   
08224 #line 1070 "frontend/machine/pentium/decoder.m"
08225                   
08226 
08227                         stmts = instantiate(pc,  "LEAVE");
08228 
08229                   
08230 
08231                   
08232                   
08233                   
08234                   
08235                   break;
08236                 case 2: 
08237                   MATCH_w_16_8 = getWord(1 + MATCH_p); 
08238                   { 
08239                     unsigned i16 = (MATCH_w_16_8 & 0xffff) /* i16 at 8 */;
08240                     nextPC = 3 + MATCH_p; 
08241                     
08242 #line 478 "frontend/machine/pentium/decoder.m"
08243                     
08244 
08245                             stmts = instantiate(pc,  "RET.far.Iw", DIS_I16);
08246 
08247                             ReturnStatement *ret = new ReturnStatement;
08248 
08249                             result.rtl = new RTL(pc, stmts);
08250 
08251                             result.rtl->appendStmt(ret);
08252 
08253                     
08254 
08255                     
08256                     
08257                     
08258                   }
08259                   
08260                   break;
08261                 case 3: 
08262                   nextPC = 1 + MATCH_p; 
08263                   
08264 #line 490 "frontend/machine/pentium/decoder.m"
08265                   
08266 
08267                         stmts = instantiate(pc,  "RET.far");
08268 
08269                         result.rtl = new RTL(pc, stmts);
08270 
08271                         result.rtl->appendStmt(new ReturnStatement);
08272 
08273                   
08274 
08275                   
08276                   
08277                   
08278                   
08279                   break;
08280                 case 4: 
08281                   goto MATCH_label_c64; break;
08282                 case 5: 
08283                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
08284                   { 
08285                     int /* [~128..127] */ i8 = 
08286                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
08287                     nextPC = 2 + MATCH_p; 
08288                     
08289 #line 1104 "frontend/machine/pentium/decoder.m"
08290                     
08291 
08292                             stmts = instantiate(pc,  "INT.Ib", DIS_I8);
08293 
08294                     
08295 
08296                     // Removing because an invalid instruction is better than trying to
08297 
08298                     // instantiate this. -trent
08299 
08300                     //    | INT3() =>
08301 
08302                     //        stmts = instantiate(pc,  "INT3");
08303 
08304                     
08305 
08306                     //    | INSvod() =>
08307 
08308                     //        stmts = instantiate(pc,  "INSvod");
08309 
08310                     
08311 
08312                     //    | INSvow() =>
08313 
08314                     //        stmts = instantiate(pc,  "INSvow");
08315 
08316                     
08317 
08318                     //    | INSB() =>
08319 
08320                     //        stmts = instantiate(pc,  "INSB");
08321 
08322                     
08323 
08324                     
08325                     
08326                     
08327                   }
08328                   
08329                   break;
08330                 case 6: 
08331                   nextPC = 1 + MATCH_p; 
08332                   
08333 #line 1101 "frontend/machine/pentium/decoder.m"
08334                   
08335 
08336                         stmts = instantiate(pc,  "INTO");
08337 
08338                   
08339 
08340                   
08341                   
08342                   
08343                   
08344                   break;
08345                 case 7: 
08346                   nextPC = 1 + MATCH_p; 
08347                   
08348 #line 1092 "frontend/machine/pentium/decoder.m"
08349                   
08350 
08351                         stmts = instantiate(pc,  "IRET");
08352 
08353                   
08354 
08355                   
08356                   
08357                   
08358                   
08359                   break;
08360                 default: assert(0);
08361               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
08362             break;
08363           case 13: 
08364             
08365               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
08366                 case 0: 
08367                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
08368                   
08369                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
08370                       case 0: 
08371                         
08372                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
08373                             case 0: 
08374                               
08375                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
08376                                   case 0: case 1: case 2: case 3: case 6: 
08377                                   case 7: 
08378                                     { 
08379                                       unsigned Mem32 = 
08380                                         1 + addressToPC(MATCH_p);
08381                                       nextPC = 2 + MATCH_p; 
08382                                       
08383 #line 1760 "frontend/machine/pentium/decoder.m"
08384                                       
08385 
08386                                             stmts = instantiate(pc,  "FADD.R32", DIS_MEM32);
08387 
08388                                       
08389 
08390                                       
08391                                       
08392                                       
08393                                     }
08394                                     
08395                                     break;
08396                                   case 4: 
08397                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
08398                                     if ((MATCH_w_8_16 & 0x7) 
08399                                             /* base at 16 */ == 5 && 
08400                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
08401                                             /* index at 16 */ && 
08402                                       (MATCH_w_8_16 >> 3 & 0x7) 
08403                                             /* index at 16 */ < 8)) 
08404                                       goto MATCH_label_c1074;  /*opt-block+*/
08405                                     else 
08406                                       goto MATCH_label_c1073;  /*opt-block+*/
08407                                     
08408                                     break;
08409                                   case 5: 
08410                                     goto MATCH_label_c1075; break;
08411                                   default: assert(0);
08412                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
08413                               break;
08414                             case 1: 
08415                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
08416                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
08417                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
08418                                       /* index at 16 */ && 
08419                                 (MATCH_w_8_16 >> 3 & 0x7) 
08420                                       /* index at 16 */ < 8)) { 
08421                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
08422                                 nextPC = 4 + MATCH_p; 
08423                                 
08424 #line 1760 "frontend/machine/pentium/decoder.m"
08425                                 
08426 
08427                                         stmts = instantiate(pc,  "FADD.R32", DIS_MEM32);
08428 
08429                                 
08430 
08431                                 
08432                                 
08433                                 
08434                               } /*opt-block*//*opt-block+*/
08435                               else 
08436                                 goto MATCH_label_c1073;  /*opt-block+*/
08437                               
08438                               break;
08439                             case 2: 
08440                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
08441                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
08442                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
08443                                       /* index at 16 */ && 
08444                                 (MATCH_w_8_16 >> 3 & 0x7) 
08445                                       /* index at 16 */ < 8)) 
08446                                 goto MATCH_label_c1074;  /*opt-block+*/
08447                               else 
08448                                 goto MATCH_label_c1075;  /*opt-block+*/
08449                               
08450                               break;
08451                             case 3: 
08452                               { 
08453                                 unsigned idx = 
08454                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
08455                                 nextPC = 2 + MATCH_p; 
08456                                 
08457 #line 1766 "frontend/machine/pentium/decoder.m"
08458                                 
08459 
08460                                         stmts = instantiate(pc,  "FADD.St.STi", DIS_IDX);
08461 
08462                                 
08463 
08464                                 
08465                                 
08466                                 
08467                               }
08468                               
08469                               break;
08470                             default: assert(0);
08471                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
08472                         break;
08473                       case 1: 
08474                         
08475                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
08476                             case 0: 
08477                               
08478                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
08479                                   case 0: case 1: case 2: case 3: case 6: 
08480                                   case 7: 
08481                                     { 
08482                                       unsigned Mem32 = 
08483                                         1 + addressToPC(MATCH_p);
08484                                       nextPC = 2 + MATCH_p; 
08485                                       
08486 #line 1954 "frontend/machine/pentium/decoder.m"
08487                                       
08488 
08489                                             stmts = instantiate(pc,  "FMUL.R32", DIS_MEM32);
08490 
08491                                       
08492 
08493                                       
08494                                       
08495                                       
08496                                     }
08497                                     
08498                                     break;
08499                                   case 4: 
08500                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
08501                                     if ((MATCH_w_8_16 & 0x7) 
08502                                             /* base at 16 */ == 5 && 
08503                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
08504                                             /* index at 16 */ && 
08505                                       (MATCH_w_8_16 >> 3 & 0x7) 
08506                                             /* index at 16 */ < 8)) 
08507                                       goto MATCH_label_c1077;  /*opt-block+*/
08508                                     else 
08509                                       goto MATCH_label_c1076;  /*opt-block+*/
08510                                     
08511                                     break;
08512                                   case 5: 
08513                                     goto MATCH_label_c1078; break;
08514                                   default: assert(0);
08515                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
08516                               break;
08517                             case 1: 
08518                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
08519                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
08520                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
08521                                       /* index at 16 */ && 
08522                                 (MATCH_w_8_16 >> 3 & 0x7) 
08523                                       /* index at 16 */ < 8)) { 
08524                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
08525                                 nextPC = 4 + MATCH_p; 
08526                                 
08527 #line 1954 "frontend/machine/pentium/decoder.m"
08528                                 
08529 
08530                                         stmts = instantiate(pc,  "FMUL.R32", DIS_MEM32);
08531 
08532                                 
08533 
08534                                 
08535                                 
08536                                 
08537                               } /*opt-block*//*opt-block+*/
08538                               else 
08539                                 goto MATCH_label_c1076;  /*opt-block+*/
08540                               
08541                               break;
08542                             case 2: 
08543                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
08544                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
08545                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
08546                                       /* index at 16 */ && 
08547                                 (MATCH_w_8_16 >> 3 & 0x7) 
08548                                       /* index at 16 */ < 8)) 
08549                                 goto MATCH_label_c1077;  /*opt-block+*/
08550                               else 
08551                                 goto MATCH_label_c1078;  /*opt-block+*/
08552                               
08553                               break;
08554                             case 3: 
08555                               { 
08556                                 unsigned idx = 
08557                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
08558                                 nextPC = 2 + MATCH_p; 
08559                                 
08560 #line 1960 "frontend/machine/pentium/decoder.m"
08561                                 
08562 
08563                                         stmts = instantiate(pc,  "FMUL.ST.STi", DIS_IDX);
08564 
08565                                 
08566 
08567                                 
08568                                 
08569                                 
08570                               }
08571                               
08572                               break;
08573                             default: assert(0);
08574                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
08575                         break;
08576                       case 2: 
08577                         
08578                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
08579                             case 0: 
08580                               
08581                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
08582                                   case 0: case 1: case 2: case 3: case 6: 
08583                                   case 7: 
08584                                     { 
08585                                       unsigned Mem32 = 
08586                                         1 + addressToPC(MATCH_p);
08587                                       nextPC = 2 + MATCH_p; 
08588                                       
08589 #line 1793 "frontend/machine/pentium/decoder.m"
08590                                       
08591 
08592                                             stmts = instantiate(pc,  "FCOM.R32", DIS_MEM32);
08593 
08594                                       
08595 
08596                                       
08597                                       
08598                                       
08599                                     }
08600                                     
08601                                     break;
08602                                   case 4: 
08603                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
08604                                     if ((MATCH_w_8_16 & 0x7) 
08605                                             /* base at 16 */ == 5 && 
08606                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
08607                                             /* index at 16 */ && 
08608                                       (MATCH_w_8_16 >> 3 & 0x7) 
08609                                             /* index at 16 */ < 8)) 
08610                                       goto MATCH_label_c1080;  /*opt-block+*/
08611                                     else 
08612                                       goto MATCH_label_c1079;  /*opt-block+*/
08613                                     
08614                                     break;
08615                                   case 5: 
08616                                     goto MATCH_label_c1081; break;
08617                                   default: assert(0);
08618                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
08619                               break;
08620                             case 1: 
08621                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
08622                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
08623                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
08624                                       /* index at 16 */ && 
08625                                 (MATCH_w_8_16 >> 3 & 0x7) 
08626                                       /* index at 16 */ < 8)) { 
08627                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
08628                                 nextPC = 4 + MATCH_p; 
08629                                 
08630 #line 1793 "frontend/machine/pentium/decoder.m"
08631                                 
08632 
08633                                         stmts = instantiate(pc,  "FCOM.R32", DIS_MEM32);
08634 
08635                                 
08636 
08637                                 
08638                                 
08639                                 
08640                               } /*opt-block*//*opt-block+*/
08641                               else 
08642                                 goto MATCH_label_c1079;  /*opt-block+*/
08643                               
08644                               break;
08645                             case 2: 
08646                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
08647                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
08648                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
08649                                       /* index at 16 */ && 
08650                                 (MATCH_w_8_16 >> 3 & 0x7) 
08651                                       /* index at 16 */ < 8)) 
08652                                 goto MATCH_label_c1080;  /*opt-block+*/
08653                               else 
08654                                 goto MATCH_label_c1081;  /*opt-block+*/
08655                               
08656                               break;
08657                             case 3: 
08658                               { 
08659                                 unsigned idx = 
08660                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
08661                                 nextPC = 2 + MATCH_p; 
08662                                 
08663 #line 1811 "frontend/machine/pentium/decoder.m"
08664                                 
08665 
08666                                         stmts = instantiate(pc,  "FCOM.ST.STi", DIS_IDX);
08667 
08668                                 
08669 
08670                                 
08671                                 
08672                                 
08673                               }
08674                               
08675                               break;
08676                             default: assert(0);
08677                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
08678                         break;
08679                       case 3: 
08680                         
08681                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
08682                             case 0: 
08683                               
08684                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
08685                                   case 0: case 1: case 2: case 3: case 6: 
08686                                   case 7: 
08687                                     { 
08688                                       unsigned Mem32 = 
08689                                         1 + addressToPC(MATCH_p);
08690                                       nextPC = 2 + MATCH_p; 
08691                                       
08692 #line 1805 "frontend/machine/pentium/decoder.m"
08693                                       
08694 
08695                                             stmts = instantiate(pc,  "FCOMP.R32", DIS_MEM32);
08696 
08697                                       
08698 
08699                                       
08700                                       
08701                                       
08702                                     }
08703                                     
08704                                     break;
08705                                   case 4: 
08706                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
08707                                     if ((MATCH_w_8_16 & 0x7) 
08708                                             /* base at 16 */ == 5 && 
08709                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
08710                                             /* index at 16 */ && 
08711                                       (MATCH_w_8_16 >> 3 & 0x7) 
08712                                             /* index at 16 */ < 8)) 
08713                                       goto MATCH_label_c1083;  /*opt-block+*/
08714                                     else 
08715                                       goto MATCH_label_c1082;  /*opt-block+*/
08716                                     
08717                                     break;
08718                                   case 5: 
08719                                     goto MATCH_label_c1084; break;
08720                                   default: assert(0);
08721                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
08722                               break;
08723                             case 1: 
08724                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
08725                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
08726                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
08727                                       /* index at 16 */ && 
08728                                 (MATCH_w_8_16 >> 3 & 0x7) 
08729                                       /* index at 16 */ < 8)) { 
08730                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
08731                                 nextPC = 4 + MATCH_p; 
08732                                 
08733 #line 1805 "frontend/machine/pentium/decoder.m"
08734                                 
08735 
08736                                         stmts = instantiate(pc,  "FCOMP.R32", DIS_MEM32);
08737 
08738                                 
08739 
08740                                 
08741                                 
08742                                 
08743                               } /*opt-block*//*opt-block+*/
08744                               else 
08745                                 goto MATCH_label_c1082;  /*opt-block+*/
08746                               
08747                               break;
08748                             case 2: 
08749                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
08750                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
08751                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
08752                                       /* index at 16 */ && 
08753                                 (MATCH_w_8_16 >> 3 & 0x7) 
08754                                       /* index at 16 */ < 8)) 
08755                                 goto MATCH_label_c1083;  /*opt-block+*/
08756                               else 
08757                                 goto MATCH_label_c1084;  /*opt-block+*/
08758                               
08759                               break;
08760                             case 3: 
08761                               { 
08762                                 unsigned idx = 
08763                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
08764                                 nextPC = 2 + MATCH_p; 
08765                                 
08766 #line 1814 "frontend/machine/pentium/decoder.m"
08767                                 
08768 
08769                                         stmts = instantiate(pc,  "FCOMP.ST.STi", DIS_IDX);
08770 
08771                                 
08772 
08773                                 
08774                                 
08775                                 
08776                               }
08777                               
08778                               break;
08779                             default: assert(0);
08780                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
08781                         break;
08782                       case 4: 
08783                         
08784                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
08785                             case 0: 
08786                               
08787                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
08788                                   case 0: case 1: case 2: case 3: case 6: 
08789                                   case 7: 
08790                                     { 
08791                                       unsigned Mem32 = 
08792                                         1 + addressToPC(MATCH_p);
08793                                       nextPC = 2 + MATCH_p; 
08794                                       
08795 #line 2044 "frontend/machine/pentium/decoder.m"
08796                                       
08797 
08798                                             stmts = instantiate(pc,  "FSUB.R32", DIS_MEM32);
08799 
08800                                       
08801 
08802                                       
08803                                       
08804                                       
08805                                     }
08806                                     
08807                                     break;
08808                                   case 4: 
08809                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
08810                                     if ((MATCH_w_8_16 & 0x7) 
08811                                             /* base at 16 */ == 5 && 
08812                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
08813                                             /* index at 16 */ && 
08814                                       (MATCH_w_8_16 >> 3 & 0x7) 
08815                                             /* index at 16 */ < 8)) 
08816                                       goto MATCH_label_c1086;  /*opt-block+*/
08817                                     else 
08818                                       goto MATCH_label_c1085;  /*opt-block+*/
08819                                     
08820                                     break;
08821                                   case 5: 
08822                                     goto MATCH_label_c1087; break;
08823                                   default: assert(0);
08824                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
08825                               break;
08826                             case 1: 
08827                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
08828                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
08829                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
08830                                       /* index at 16 */ && 
08831                                 (MATCH_w_8_16 >> 3 & 0x7) 
08832                                       /* index at 16 */ < 8)) { 
08833                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
08834                                 nextPC = 4 + MATCH_p; 
08835                                 
08836 #line 2044 "frontend/machine/pentium/decoder.m"
08837                                 
08838 
08839                                         stmts = instantiate(pc,  "FSUB.R32", DIS_MEM32);
08840 
08841                                 
08842 
08843                                 
08844                                 
08845                                 
08846                               } /*opt-block*//*opt-block+*/
08847                               else 
08848                                 goto MATCH_label_c1085;  /*opt-block+*/
08849                               
08850                               break;
08851                             case 2: 
08852                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
08853                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
08854                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
08855                                       /* index at 16 */ && 
08856                                 (MATCH_w_8_16 >> 3 & 0x7) 
08857                                       /* index at 16 */ < 8)) 
08858                                 goto MATCH_label_c1086;  /*opt-block+*/
08859                               else 
08860                                 goto MATCH_label_c1087;  /*opt-block+*/
08861                               
08862                               break;
08863                             case 3: 
08864                               { 
08865                                 unsigned idx = 
08866                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
08867                                 nextPC = 2 + MATCH_p; 
08868                                 
08869 #line 2050 "frontend/machine/pentium/decoder.m"
08870                                 
08871 
08872                                         stmts = instantiate(pc,  "FSUB.ST.STi", DIS_IDX);
08873 
08874                                 
08875 
08876                                 
08877                                 
08878                                 
08879                               }
08880                               
08881                               break;
08882                             default: assert(0);
08883                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
08884                         break;
08885                       case 5: 
08886                         
08887                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
08888                             case 0: 
08889                               
08890                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
08891                                   case 0: case 1: case 2: case 3: case 6: 
08892                                   case 7: 
08893                                     { 
08894                                       unsigned Mem32 = 
08895                                         1 + addressToPC(MATCH_p);
08896                                       nextPC = 2 + MATCH_p; 
08897                                       
08898 #line 2065 "frontend/machine/pentium/decoder.m"
08899                                       
08900 
08901                                             stmts = instantiate(pc,  "FSUBR.R32", DIS_MEM32);
08902 
08903                                       
08904 
08905                                       
08906                                       
08907                                       
08908                                     }
08909                                     
08910                                     break;
08911                                   case 4: 
08912                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
08913                                     if ((MATCH_w_8_16 & 0x7) 
08914                                             /* base at 16 */ == 5 && 
08915                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
08916                                             /* index at 16 */ && 
08917                                       (MATCH_w_8_16 >> 3 & 0x7) 
08918                                             /* index at 16 */ < 8)) 
08919                                       goto MATCH_label_c1089;  /*opt-block+*/
08920                                     else 
08921                                       goto MATCH_label_c1088;  /*opt-block+*/
08922                                     
08923                                     break;
08924                                   case 5: 
08925                                     goto MATCH_label_c1090; break;
08926                                   default: assert(0);
08927                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
08928                               break;
08929                             case 1: 
08930                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
08931                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
08932                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
08933                                       /* index at 16 */ && 
08934                                 (MATCH_w_8_16 >> 3 & 0x7) 
08935                                       /* index at 16 */ < 8)) { 
08936                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
08937                                 nextPC = 4 + MATCH_p; 
08938                                 
08939 #line 2065 "frontend/machine/pentium/decoder.m"
08940                                 
08941 
08942                                         stmts = instantiate(pc,  "FSUBR.R32", DIS_MEM32);
08943 
08944                                 
08945 
08946                                 
08947                                 
08948                                 
08949                               } /*opt-block*//*opt-block+*/
08950                               else 
08951                                 goto MATCH_label_c1088;  /*opt-block+*/
08952                               
08953                               break;
08954                             case 2: 
08955                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
08956                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
08957                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
08958                                       /* index at 16 */ && 
08959                                 (MATCH_w_8_16 >> 3 & 0x7) 
08960                                       /* index at 16 */ < 8)) 
08961                                 goto MATCH_label_c1089;  /*opt-block+*/
08962                               else 
08963                                 goto MATCH_label_c1090;  /*opt-block+*/
08964                               
08965                               break;
08966                             case 3: 
08967                               { 
08968                                 unsigned idx = 
08969                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
08970                                 nextPC = 2 + MATCH_p; 
08971                                 
08972 #line 2071 "frontend/machine/pentium/decoder.m"
08973                                 
08974 
08975                                         stmts = instantiate(pc,  "FSUBR.ST.STi", DIS_IDX);
08976 
08977                                 
08978 
08979                                 
08980                                 
08981                                 
08982                               }
08983                               
08984                               break;
08985                             default: assert(0);
08986                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
08987                         break;
08988                       case 6: 
08989                         
08990                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
08991                             case 0: 
08992                               
08993                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
08994                                   case 0: case 1: case 2: case 3: case 6: 
08995                                   case 7: 
08996                                     { 
08997                                       unsigned Mem32 = 
08998                                         1 + addressToPC(MATCH_p);
08999                                       nextPC = 2 + MATCH_p; 
09000                                       
09001 #line 1838 "frontend/machine/pentium/decoder.m"
09002                                       
09003 
09004                                             stmts = instantiate(pc,  "FDIV.R32", DIS_MEM32);
09005 
09006                                       
09007 
09008                                       
09009                                       
09010                                       
09011                                     }
09012                                     
09013                                     break;
09014                                   case 4: 
09015                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
09016                                     if ((MATCH_w_8_16 & 0x7) 
09017                                             /* base at 16 */ == 5 && 
09018                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09019                                             /* index at 16 */ && 
09020                                       (MATCH_w_8_16 >> 3 & 0x7) 
09021                                             /* index at 16 */ < 8)) 
09022                                       goto MATCH_label_c1092;  /*opt-block+*/
09023                                     else 
09024                                       goto MATCH_label_c1091;  /*opt-block+*/
09025                                     
09026                                     break;
09027                                   case 5: 
09028                                     goto MATCH_label_c1093; break;
09029                                   default: assert(0);
09030                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
09031                               break;
09032                             case 1: 
09033                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
09034                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
09035                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09036                                       /* index at 16 */ && 
09037                                 (MATCH_w_8_16 >> 3 & 0x7) 
09038                                       /* index at 16 */ < 8)) { 
09039                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
09040                                 nextPC = 4 + MATCH_p; 
09041                                 
09042 #line 1838 "frontend/machine/pentium/decoder.m"
09043                                 
09044 
09045                                         stmts = instantiate(pc,  "FDIV.R32", DIS_MEM32);
09046 
09047                                 
09048 
09049                                 
09050                                 
09051                                 
09052                               } /*opt-block*//*opt-block+*/
09053                               else 
09054                                 goto MATCH_label_c1091;  /*opt-block+*/
09055                               
09056                               break;
09057                             case 2: 
09058                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
09059                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
09060                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09061                                       /* index at 16 */ && 
09062                                 (MATCH_w_8_16 >> 3 & 0x7) 
09063                                       /* index at 16 */ < 8)) 
09064                                 goto MATCH_label_c1092;  /*opt-block+*/
09065                               else 
09066                                 goto MATCH_label_c1093;  /*opt-block+*/
09067                               
09068                               break;
09069                             case 3: 
09070                               { 
09071                                 unsigned idx = 
09072                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
09073                                 nextPC = 2 + MATCH_p; 
09074                                 
09075 #line 1844 "frontend/machine/pentium/decoder.m"
09076                                 
09077 
09078                                         stmts = instantiate(pc,  "FDIV.ST.STi", DIS_IDX);
09079 
09080                                 
09081 
09082                                 
09083                                 
09084                                 
09085                               }
09086                               
09087                               break;
09088                             default: assert(0);
09089                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
09090                         break;
09091                       case 7: 
09092                         
09093                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
09094                             case 0: 
09095                               
09096                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
09097                                   case 0: case 1: case 2: case 3: case 6: 
09098                                   case 7: 
09099                                     { 
09100                                       unsigned Mem32 = 
09101                                         1 + addressToPC(MATCH_p);
09102                                       nextPC = 2 + MATCH_p; 
09103                                       
09104 #line 1859 "frontend/machine/pentium/decoder.m"
09105                                       
09106 
09107                                             stmts = instantiate(pc,  "FDIVR.R32", DIS_MEM32);
09108 
09109                                       
09110 
09111                                       
09112                                       
09113                                       
09114                                     }
09115                                     
09116                                     break;
09117                                   case 4: 
09118                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
09119                                     if ((MATCH_w_8_16 & 0x7) 
09120                                             /* base at 16 */ == 5 && 
09121                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09122                                             /* index at 16 */ && 
09123                                       (MATCH_w_8_16 >> 3 & 0x7) 
09124                                             /* index at 16 */ < 8)) 
09125                                       goto MATCH_label_c1095;  /*opt-block+*/
09126                                     else 
09127                                       goto MATCH_label_c1094;  /*opt-block+*/
09128                                     
09129                                     break;
09130                                   case 5: 
09131                                     goto MATCH_label_c1096; break;
09132                                   default: assert(0);
09133                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
09134                               break;
09135                             case 1: 
09136                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
09137                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
09138                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09139                                       /* index at 16 */ && 
09140                                 (MATCH_w_8_16 >> 3 & 0x7) 
09141                                       /* index at 16 */ < 8)) { 
09142                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
09143                                 nextPC = 4 + MATCH_p; 
09144                                 
09145 #line 1859 "frontend/machine/pentium/decoder.m"
09146                                 
09147 
09148                                         stmts = instantiate(pc,  "FDIVR.R32", DIS_MEM32);
09149 
09150                                 
09151 
09152                                 
09153                                 
09154                                 
09155                               } /*opt-block*//*opt-block+*/
09156                               else 
09157                                 goto MATCH_label_c1094;  /*opt-block+*/
09158                               
09159                               break;
09160                             case 2: 
09161                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
09162                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
09163                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09164                                       /* index at 16 */ && 
09165                                 (MATCH_w_8_16 >> 3 & 0x7) 
09166                                       /* index at 16 */ < 8)) 
09167                                 goto MATCH_label_c1095;  /*opt-block+*/
09168                               else 
09169                                 goto MATCH_label_c1096;  /*opt-block+*/
09170                               
09171                               break;
09172                             case 3: 
09173                               { 
09174                                 unsigned idx = 
09175                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
09176                                 nextPC = 2 + MATCH_p; 
09177                                 
09178 #line 1865 "frontend/machine/pentium/decoder.m"
09179                                 
09180 
09181                                         stmts = instantiate(pc,  "FDIVR.ST.STi", DIS_IDX);
09182 
09183                                 
09184 
09185                                 
09186                                 
09187                                 
09188                               }
09189                               
09190                               break;
09191                             default: assert(0);
09192                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
09193                         break;
09194                       default: assert(0);
09195                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
09196                   
09197                   break;
09198                 case 1: 
09199                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
09200                   
09201                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
09202                       case 0: 
09203                         
09204                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
09205                             case 0: 
09206                               
09207                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
09208                                   case 0: case 1: case 2: case 3: case 6: 
09209                                   case 7: 
09210                                     { 
09211                                       unsigned Mem32 = 
09212                                         1 + addressToPC(MATCH_p);
09213                                       nextPC = 2 + MATCH_p; 
09214                                       
09215 #line 1910 "frontend/machine/pentium/decoder.m"
09216                                       
09217 
09218                                             stmts = instantiate(pc,  "FLD.lsR32", DIS_MEM32);
09219 
09220                                       
09221 
09222                                       
09223                                       
09224                                       
09225                                     }
09226                                     
09227                                     break;
09228                                   case 4: 
09229                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
09230                                     if ((MATCH_w_8_16 & 0x7) 
09231                                             /* base at 16 */ == 5 && 
09232                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09233                                             /* index at 16 */ && 
09234                                       (MATCH_w_8_16 >> 3 & 0x7) 
09235                                             /* index at 16 */ < 8)) 
09236                                       goto MATCH_label_c1098;  /*opt-block+*/
09237                                     else 
09238                                       goto MATCH_label_c1097;  /*opt-block+*/
09239                                     
09240                                     break;
09241                                   case 5: 
09242                                     goto MATCH_label_c1099; break;
09243                                   default: assert(0);
09244                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
09245                               break;
09246                             case 1: 
09247                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
09248                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
09249                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09250                                       /* index at 16 */ && 
09251                                 (MATCH_w_8_16 >> 3 & 0x7) 
09252                                       /* index at 16 */ < 8)) { 
09253                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
09254                                 nextPC = 4 + MATCH_p; 
09255                                 
09256 #line 1910 "frontend/machine/pentium/decoder.m"
09257                                 
09258 
09259                                         stmts = instantiate(pc,  "FLD.lsR32", DIS_MEM32);
09260 
09261                                 
09262 
09263                                 
09264                                 
09265                                 
09266                               } /*opt-block*//*opt-block+*/
09267                               else 
09268                                 goto MATCH_label_c1097;  /*opt-block+*/
09269                               
09270                               break;
09271                             case 2: 
09272                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
09273                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
09274                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09275                                       /* index at 16 */ && 
09276                                 (MATCH_w_8_16 >> 3 & 0x7) 
09277                                       /* index at 16 */ < 8)) 
09278                                 goto MATCH_label_c1098;  /*opt-block+*/
09279                               else 
09280                                 goto MATCH_label_c1099;  /*opt-block+*/
09281                               
09282                               break;
09283                             case 3: 
09284                               { 
09285                                 unsigned idx = 
09286                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
09287                                 nextPC = 2 + MATCH_p; 
09288                                 
09289 #line 1924 "frontend/machine/pentium/decoder.m"
09290                                 
09291 
09292                                         stmts = instantiate(pc,  "FLD.STi", DIS_IDXP1);
09293 
09294                                 
09295 
09296                                 
09297                                 
09298                                 
09299                               }
09300                               
09301                               break;
09302                             default: assert(0);
09303                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
09304                         break;
09305                       case 1: 
09306                         if ((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */ == 3) { 
09307                           unsigned idx = (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
09308                           nextPC = 2 + MATCH_p; 
09309                           
09310 #line 2107 "frontend/machine/pentium/decoder.m"
09311                           
09312 
09313                                 stmts = instantiate(pc,  "FXCH", DIS_IDX);
09314 
09315                           
09316 
09317                           
09318                           
09319                           
09320                         } /*opt-block*//*opt-block+*/
09321                         else 
09322                           goto MATCH_label_c64;  /*opt-block+*/
09323                         
09324                         break;
09325                       case 2: 
09326                         
09327                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
09328                             case 0: 
09329                               
09330                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
09331                                   case 0: case 1: case 2: case 3: case 6: 
09332                                   case 7: 
09333                                     { 
09334                                       unsigned Mem32 = 
09335                                         1 + addressToPC(MATCH_p);
09336                                       nextPC = 2 + MATCH_p; 
09337                                       
09338 #line 2011 "frontend/machine/pentium/decoder.m"
09339                                       
09340 
09341                                             stmts = instantiate(pc,  "FST.lsR32", DIS_MEM32);
09342 
09343                                       
09344 
09345                                       
09346                                       
09347                                       
09348                                     }
09349                                     
09350                                     break;
09351                                   case 4: 
09352                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
09353                                     if ((MATCH_w_8_16 & 0x7) 
09354                                             /* base at 16 */ == 5 && 
09355                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09356                                             /* index at 16 */ && 
09357                                       (MATCH_w_8_16 >> 3 & 0x7) 
09358                                             /* index at 16 */ < 8)) 
09359                                       goto MATCH_label_c1101;  /*opt-block+*/
09360                                     else 
09361                                       goto MATCH_label_c1100;  /*opt-block+*/
09362                                     
09363                                     break;
09364                                   case 5: 
09365                                     goto MATCH_label_c1102; break;
09366                                   default: assert(0);
09367                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
09368                               break;
09369                             case 1: 
09370                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
09371                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
09372                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09373                                       /* index at 16 */ && 
09374                                 (MATCH_w_8_16 >> 3 & 0x7) 
09375                                       /* index at 16 */ < 8)) { 
09376                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
09377                                 nextPC = 4 + MATCH_p; 
09378                                 
09379 #line 2011 "frontend/machine/pentium/decoder.m"
09380                                 
09381 
09382                                         stmts = instantiate(pc,  "FST.lsR32", DIS_MEM32);
09383 
09384                                 
09385 
09386                                 
09387                                 
09388                                 
09389                               } /*opt-block*//*opt-block+*/
09390                               else 
09391                                 goto MATCH_label_c1100;  /*opt-block+*/
09392                               
09393                               break;
09394                             case 2: 
09395                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
09396                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
09397                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09398                                       /* index at 16 */ && 
09399                                 (MATCH_w_8_16 >> 3 & 0x7) 
09400                                       /* index at 16 */ < 8)) 
09401                                 goto MATCH_label_c1101;  /*opt-block+*/
09402                               else 
09403                                 goto MATCH_label_c1102;  /*opt-block+*/
09404                               
09405                               break;
09406                             case 3: 
09407                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 0) { 
09408                                 nextPC = 2 + MATCH_p; 
09409                                 
09410 #line 1975 "frontend/machine/pentium/decoder.m"
09411                                 
09412 
09413                                         stmts = instantiate(pc,  "FNOP");
09414 
09415                                 
09416 
09417                                 
09418                                 
09419                                 
09420                               } /*opt-block*//*opt-block+*/
09421                               else 
09422                                 goto MATCH_label_c64;  /*opt-block+*/
09423                               
09424                               break;
09425                             default: assert(0);
09426                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
09427                         break;
09428                       case 3: 
09429                         
09430                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
09431                             case 0: 
09432                               
09433                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
09434                                   case 0: case 1: case 2: case 3: case 6: 
09435                                   case 7: 
09436                                     { 
09437                                       unsigned Mem32 = 
09438                                         1 + addressToPC(MATCH_p);
09439                                       nextPC = 2 + MATCH_p; 
09440                                       
09441 #line 2017 "frontend/machine/pentium/decoder.m"
09442                                       
09443 
09444                                             stmts = instantiate(pc,  "FSTP.lsR32", DIS_MEM32);
09445 
09446                                       
09447 
09448                                       
09449                                       
09450                                       
09451                                     }
09452                                     
09453                                     break;
09454                                   case 4: 
09455                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
09456                                     if ((MATCH_w_8_16 & 0x7) 
09457                                             /* base at 16 */ == 5 && 
09458                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09459                                             /* index at 16 */ && 
09460                                       (MATCH_w_8_16 >> 3 & 0x7) 
09461                                             /* index at 16 */ < 8)) 
09462                                       goto MATCH_label_c1104;  /*opt-block+*/
09463                                     else 
09464                                       goto MATCH_label_c1103;  /*opt-block+*/
09465                                     
09466                                     break;
09467                                   case 5: 
09468                                     goto MATCH_label_c1105; break;
09469                                   default: assert(0);
09470                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
09471                               break;
09472                             case 1: 
09473                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
09474                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
09475                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09476                                       /* index at 16 */ && 
09477                                 (MATCH_w_8_16 >> 3 & 0x7) 
09478                                       /* index at 16 */ < 8)) { 
09479                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
09480                                 nextPC = 4 + MATCH_p; 
09481                                 
09482 #line 2017 "frontend/machine/pentium/decoder.m"
09483                                 
09484 
09485                                         stmts = instantiate(pc,  "FSTP.lsR32", DIS_MEM32);
09486 
09487                                 
09488 
09489                                 
09490                                 
09491                                 
09492                               } /*opt-block*//*opt-block+*/
09493                               else 
09494                                 goto MATCH_label_c1103;  /*opt-block+*/
09495                               
09496                               break;
09497                             case 2: 
09498                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
09499                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
09500                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09501                                       /* index at 16 */ && 
09502                                 (MATCH_w_8_16 >> 3 & 0x7) 
09503                                       /* index at 16 */ < 8)) 
09504                                 goto MATCH_label_c1104;  /*opt-block+*/
09505                               else 
09506                                 goto MATCH_label_c1105;  /*opt-block+*/
09507                               
09508                               break;
09509                             case 3: 
09510                               goto MATCH_label_c64; break;
09511                             default: assert(0);
09512                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
09513                         break;
09514                       case 4: 
09515                         
09516                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
09517                             case 0: 
09518                               
09519                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
09520                                   case 0: case 1: case 2: case 3: case 6: 
09521                                   case 7: 
09522                                     { 
09523                                       unsigned Mem = 1 + addressToPC(MATCH_p);
09524                                       nextPC = 2 + MATCH_p; 
09525                                       
09526 #line 1951 "frontend/machine/pentium/decoder.m"
09527                                       
09528 
09529                                             stmts = instantiate(pc,  "FLDENV", DIS_MEM);
09530 
09531                                       
09532 
09533                                       
09534                                       
09535                                       
09536                                     }
09537                                     
09538                                     break;
09539                                   case 4: 
09540                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
09541                                     if ((MATCH_w_8_16 & 0x7) 
09542                                             /* base at 16 */ == 5 && 
09543                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09544                                             /* index at 16 */ && 
09545                                       (MATCH_w_8_16 >> 3 & 0x7) 
09546                                             /* index at 16 */ < 8)) 
09547                                       goto MATCH_label_c1107;  /*opt-block+*/
09548                                     else 
09549                                       goto MATCH_label_c1106;  /*opt-block+*/
09550                                     
09551                                     break;
09552                                   case 5: 
09553                                     goto MATCH_label_c1108; break;
09554                                   default: assert(0);
09555                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
09556                               break;
09557                             case 1: 
09558                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
09559                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
09560                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09561                                       /* index at 16 */ && 
09562                                 (MATCH_w_8_16 >> 3 & 0x7) 
09563                                       /* index at 16 */ < 8)) { 
09564                                 unsigned Mem = 1 + addressToPC(MATCH_p);
09565                                 nextPC = 4 + MATCH_p; 
09566                                 
09567 #line 1951 "frontend/machine/pentium/decoder.m"
09568                                 
09569 
09570                                         stmts = instantiate(pc,  "FLDENV", DIS_MEM);
09571 
09572                                 
09573 
09574                                 
09575                                 
09576                                 
09577                               } /*opt-block*//*opt-block+*/
09578                               else 
09579                                 goto MATCH_label_c1106;  /*opt-block+*/
09580                               
09581                               break;
09582                             case 2: 
09583                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
09584                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
09585                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09586                                       /* index at 16 */ && 
09587                                 (MATCH_w_8_16 >> 3 & 0x7) 
09588                                       /* index at 16 */ < 8)) 
09589                                 goto MATCH_label_c1107;  /*opt-block+*/
09590                               else 
09591                                 goto MATCH_label_c1108;  /*opt-block+*/
09592                               
09593                               break;
09594                             case 3: 
09595                               
09596                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
09597                                   case 0: 
09598                                     nextPC = 2 + MATCH_p; 
09599                                     
09600 #line 1787 "frontend/machine/pentium/decoder.m"
09601                                     
09602 
09603                                             stmts = instantiate(pc,  "FCHS");
09604 
09605                                     
09606 
09607                                     
09608                                     
09609                                     
09610                                     
09611                                     break;
09612                                   case 1: 
09613                                     nextPC = 2 + MATCH_p; 
09614                                     
09615 #line 1757 "frontend/machine/pentium/decoder.m"
09616                                     
09617 
09618                                             stmts = instantiate(pc,  "FABS");
09619 
09620                                     
09621 
09622                                     
09623                                     
09624                                     
09625                                     
09626                                     break;
09627                                   case 2: case 3: case 6: case 7: 
09628                                     goto MATCH_label_c64; break;
09629                                   case 4: 
09630                                     nextPC = 2 + MATCH_p; 
09631                                     
09632 #line 2086 "frontend/machine/pentium/decoder.m"
09633                                     
09634 
09635                                             stmts = instantiate(pc,  "FTST");
09636 
09637                                     
09638 
09639                                     
09640                                     
09641                                     
09642                                     
09643                                     break;
09644                                   case 5: 
09645                                     nextPC = 2 + MATCH_p; 
09646                                     
09647 #line 2104 "frontend/machine/pentium/decoder.m"
09648                                     
09649 
09650                                             stmts = instantiate(pc,  "FXAM");
09651 
09652                                     
09653 
09654                                     
09655                                     
09656                                     
09657                                     
09658                                     break;
09659                                   default: assert(0);
09660                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
09661                               break;
09662                             default: assert(0);
09663                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
09664                         break;
09665                       case 5: 
09666                         
09667                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
09668                             case 0: 
09669                               
09670                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
09671                                   case 0: case 1: case 2: case 3: case 6: 
09672                                   case 7: 
09673                                     { 
09674                                       unsigned Mem16 = 
09675                                         1 + addressToPC(MATCH_p);
09676                                       nextPC = 2 + MATCH_p; 
09677                                       
09678 #line 1948 "frontend/machine/pentium/decoder.m"
09679                                       
09680 
09681                                             stmts = instantiate(pc,  "FLDCW", DIS_MEM16);
09682 
09683                                       
09684 
09685                                       
09686                                       
09687                                       
09688                                     }
09689                                     
09690                                     break;
09691                                   case 4: 
09692                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
09693                                     if ((MATCH_w_8_16 & 0x7) 
09694                                             /* base at 16 */ == 5 && 
09695                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09696                                             /* index at 16 */ && 
09697                                       (MATCH_w_8_16 >> 3 & 0x7) 
09698                                             /* index at 16 */ < 8)) 
09699                                       goto MATCH_label_c1110;  /*opt-block+*/
09700                                     else 
09701                                       goto MATCH_label_c1109;  /*opt-block+*/
09702                                     
09703                                     break;
09704                                   case 5: 
09705                                     goto MATCH_label_c1111; break;
09706                                   default: assert(0);
09707                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
09708                               break;
09709                             case 1: 
09710                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
09711                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
09712                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09713                                       /* index at 16 */ && 
09714                                 (MATCH_w_8_16 >> 3 & 0x7) 
09715                                       /* index at 16 */ < 8)) { 
09716                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
09717                                 nextPC = 4 + MATCH_p; 
09718                                 
09719 #line 1948 "frontend/machine/pentium/decoder.m"
09720                                 
09721 
09722                                         stmts = instantiate(pc,  "FLDCW", DIS_MEM16);
09723 
09724                                 
09725 
09726                                 
09727                                 
09728                                 
09729                               } /*opt-block*//*opt-block+*/
09730                               else 
09731                                 goto MATCH_label_c1109;  /*opt-block+*/
09732                               
09733                               break;
09734                             case 2: 
09735                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
09736                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
09737                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09738                                       /* index at 16 */ && 
09739                                 (MATCH_w_8_16 >> 3 & 0x7) 
09740                                       /* index at 16 */ < 8)) 
09741                                 goto MATCH_label_c1110;  /*opt-block+*/
09742                               else 
09743                                 goto MATCH_label_c1111;  /*opt-block+*/
09744                               
09745                               break;
09746                             case 3: 
09747                               
09748                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
09749                                   case 0: 
09750                                     nextPC = 2 + MATCH_p; 
09751                                     
09752 #line 1927 "frontend/machine/pentium/decoder.m"
09753                                     
09754 
09755                                             stmts = instantiate(pc,  "FLD1");
09756 
09757                                     
09758 
09759                                     
09760                                     
09761                                     
09762                                     
09763                                     break;
09764                                   case 1: 
09765                                     nextPC = 2 + MATCH_p; 
09766                                     
09767 #line 1930 "frontend/machine/pentium/decoder.m"
09768                                     
09769 
09770                                             stmts = instantiate(pc,  "FLDL2T");
09771 
09772                                     
09773 
09774                                     
09775                                     
09776                                     
09777                                     
09778                                     break;
09779                                   case 2: 
09780                                     nextPC = 2 + MATCH_p; 
09781                                     
09782 #line 1933 "frontend/machine/pentium/decoder.m"
09783                                     
09784 
09785                                             stmts = instantiate(pc,  "FLDL2E");
09786 
09787                                     
09788 
09789                                     
09790                                     
09791                                     
09792                                     
09793                                     break;
09794                                   case 3: 
09795                                     nextPC = 2 + MATCH_p; 
09796                                     
09797 #line 1936 "frontend/machine/pentium/decoder.m"
09798                                     
09799 
09800                                             stmts = instantiate(pc,  "FLDPI");
09801 
09802                                     
09803 
09804                                     
09805                                     
09806                                     
09807                                     
09808                                     break;
09809                                   case 4: 
09810                                     nextPC = 2 + MATCH_p; 
09811                                     
09812 #line 1939 "frontend/machine/pentium/decoder.m"
09813                                     
09814 
09815                                             stmts = instantiate(pc,  "FLDLG2");
09816 
09817                                     
09818 
09819                                     
09820                                     
09821                                     
09822                                     
09823                                     break;
09824                                   case 5: 
09825                                     nextPC = 2 + MATCH_p; 
09826                                     
09827 #line 1942 "frontend/machine/pentium/decoder.m"
09828                                     
09829 
09830                                             stmts = instantiate(pc,  "FLDLN2");
09831 
09832                                     
09833 
09834                                     
09835                                     
09836                                     
09837                                     
09838                                     break;
09839                                   case 6: 
09840                                     nextPC = 2 + MATCH_p; 
09841                                     
09842 #line 1945 "frontend/machine/pentium/decoder.m"
09843                                     
09844 
09845                                             stmts = instantiate(pc,  "FLDZ");
09846 
09847                                     
09848 
09849                                     
09850                                     
09851                                     
09852                                     
09853                                     break;
09854                                   case 7: 
09855                                     goto MATCH_label_c64; break;
09856                                   default: assert(0);
09857                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
09858                               break;
09859                             default: assert(0);
09860                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
09861                         break;
09862                       case 6: 
09863                         
09864                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
09865                             case 0: 
09866                               
09867                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
09868                                   case 0: case 1: case 2: case 3: case 6: 
09869                                   case 7: 
09870                                     { 
09871                                       unsigned Mem = 1 + addressToPC(MATCH_p);
09872                                       nextPC = 2 + MATCH_p; 
09873                                       
09874 #line 2035 "frontend/machine/pentium/decoder.m"
09875                                       
09876 
09877                                             stmts = instantiate(pc,  "FSTENV", DIS_MEM);
09878 
09879                                       
09880 
09881                                       
09882                                       
09883                                       
09884                                     }
09885                                     
09886                                     break;
09887                                   case 4: 
09888                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
09889                                     if ((MATCH_w_8_16 & 0x7) 
09890                                             /* base at 16 */ == 5 && 
09891                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09892                                             /* index at 16 */ && 
09893                                       (MATCH_w_8_16 >> 3 & 0x7) 
09894                                             /* index at 16 */ < 8)) 
09895                                       goto MATCH_label_c1113;  /*opt-block+*/
09896                                     else 
09897                                       goto MATCH_label_c1112;  /*opt-block+*/
09898                                     
09899                                     break;
09900                                   case 5: 
09901                                     goto MATCH_label_c1114; break;
09902                                   default: assert(0);
09903                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
09904                               break;
09905                             case 1: 
09906                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
09907                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
09908                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09909                                       /* index at 16 */ && 
09910                                 (MATCH_w_8_16 >> 3 & 0x7) 
09911                                       /* index at 16 */ < 8)) { 
09912                                 unsigned Mem = 1 + addressToPC(MATCH_p);
09913                                 nextPC = 4 + MATCH_p; 
09914                                 
09915 #line 2035 "frontend/machine/pentium/decoder.m"
09916                                 
09917 
09918                                         stmts = instantiate(pc,  "FSTENV", DIS_MEM);
09919 
09920                                 
09921 
09922                                 
09923                                 
09924                                 
09925                               } /*opt-block*//*opt-block+*/
09926                               else 
09927                                 goto MATCH_label_c1112;  /*opt-block+*/
09928                               
09929                               break;
09930                             case 2: 
09931                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
09932                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
09933                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
09934                                       /* index at 16 */ && 
09935                                 (MATCH_w_8_16 >> 3 & 0x7) 
09936                                       /* index at 16 */ < 8)) 
09937                                 goto MATCH_label_c1113;  /*opt-block+*/
09938                               else 
09939                                 goto MATCH_label_c1114;  /*opt-block+*/
09940                               
09941                               break;
09942                             case 3: 
09943                               
09944                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
09945                                   case 0: 
09946                                     nextPC = 2 + MATCH_p; 
09947                                     
09948 #line 1754 "frontend/machine/pentium/decoder.m"
09949                                     
09950 
09951                                             stmts = instantiate(pc,  "F2XM1");
09952 
09953                                     
09954 
09955                                     
09956                                     
09957                                     
09958                                     
09959                                     break;
09960                                   case 1: 
09961                                     nextPC = 2 + MATCH_p; 
09962                                     
09963 #line 2113 "frontend/machine/pentium/decoder.m"
09964                                     
09965 
09966                                             stmts = instantiate(pc,  "FYL2X");
09967 
09968                                     
09969 
09970                                     
09971                                     
09972                                     
09973                                     
09974                                     break;
09975                                   case 2: 
09976                                     nextPC = 2 + MATCH_p; 
09977                                     
09978 #line 1987 "frontend/machine/pentium/decoder.m"
09979                                     
09980 
09981                                             stmts = instantiate(pc,  "FPTAN");
09982 
09983                                     
09984 
09985                                     
09986                                     
09987                                     
09988                                     
09989                                     break;
09990                                   case 3: 
09991                                     nextPC = 2 + MATCH_p; 
09992                                     
09993 #line 1978 "frontend/machine/pentium/decoder.m"
09994                                     
09995 
09996                                             stmts = instantiate(pc,  "FPATAN");
09997 
09998                                     
09999 
10000                                     
10001                                     
10002                                     
10003                                     
10004                                     break;
10005                                   case 4: 
10006                                     nextPC = 2 + MATCH_p; 
10007                                     
10008 #line 2110 "frontend/machine/pentium/decoder.m"
10009                                     
10010 
10011                                             stmts = instantiate(pc,  "FXTRACT");
10012 
10013                                     
10014 
10015                                     
10016                                     
10017                                     
10018                                     
10019                                     break;
10020                                   case 5: 
10021                                     nextPC = 2 + MATCH_p; 
10022                                     
10023 #line 1984 "frontend/machine/pentium/decoder.m"
10024                                     
10025 
10026                                             stmts = instantiate(pc,  "FPREM1");
10027 
10028                                     
10029 
10030                                     
10031                                     
10032                                     
10033                                     
10034                                     break;
10035                                   case 6: 
10036                                     nextPC = 2 + MATCH_p; 
10037                                     
10038 #line 1835 "frontend/machine/pentium/decoder.m"
10039                                     
10040 
10041                                             stmts = instantiate(pc,  "FDECSTP");
10042 
10043                                     
10044 
10045                                     
10046                                     
10047                                     
10048                                     
10049                                     break;
10050                                   case 7: 
10051                                     goto MATCH_label_c64; break;
10052                                   default: assert(0);
10053                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
10054                               break;
10055                             default: assert(0);
10056                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
10057                         break;
10058                       case 7: 
10059                         
10060                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
10061                             case 0: 
10062                               
10063                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
10064                                   case 0: case 1: case 2: case 3: case 6: 
10065                                   case 7: 
10066                                     { 
10067                                       unsigned Mem16 = 
10068                                         1 + addressToPC(MATCH_p);
10069                                       nextPC = 2 + MATCH_p; 
10070                                       
10071 #line 2032 "frontend/machine/pentium/decoder.m"
10072                                       
10073 
10074                                             stmts = instantiate(pc,  "FSTCW", DIS_MEM16);
10075 
10076                                       
10077 
10078                                       
10079                                       
10080                                       
10081                                     }
10082                                     
10083                                     break;
10084                                   case 4: 
10085                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
10086                                     if ((MATCH_w_8_16 & 0x7) 
10087                                             /* base at 16 */ == 5 && 
10088                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10089                                             /* index at 16 */ && 
10090                                       (MATCH_w_8_16 >> 3 & 0x7) 
10091                                             /* index at 16 */ < 8)) 
10092                                       goto MATCH_label_c1116;  /*opt-block+*/
10093                                     else 
10094                                       goto MATCH_label_c1115;  /*opt-block+*/
10095                                     
10096                                     break;
10097                                   case 5: 
10098                                     goto MATCH_label_c1117; break;
10099                                   default: assert(0);
10100                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
10101                               break;
10102                             case 1: 
10103                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
10104                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
10105                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10106                                       /* index at 16 */ && 
10107                                 (MATCH_w_8_16 >> 3 & 0x7) 
10108                                       /* index at 16 */ < 8)) { 
10109                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
10110                                 nextPC = 4 + MATCH_p; 
10111                                 
10112 #line 2032 "frontend/machine/pentium/decoder.m"
10113                                 
10114 
10115                                         stmts = instantiate(pc,  "FSTCW", DIS_MEM16);
10116 
10117                                 
10118 
10119                                 
10120                                 
10121                                 
10122                               } /*opt-block*//*opt-block+*/
10123                               else 
10124                                 goto MATCH_label_c1115;  /*opt-block+*/
10125                               
10126                               break;
10127                             case 2: 
10128                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
10129                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
10130                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10131                                       /* index at 16 */ && 
10132                                 (MATCH_w_8_16 >> 3 & 0x7) 
10133                                       /* index at 16 */ < 8)) 
10134                                 goto MATCH_label_c1116;  /*opt-block+*/
10135                               else 
10136                                 goto MATCH_label_c1117;  /*opt-block+*/
10137                               
10138                               break;
10139                             case 3: 
10140                               
10141                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
10142                                   case 0: 
10143                                     nextPC = 2 + MATCH_p; 
10144                                     
10145 #line 1981 "frontend/machine/pentium/decoder.m"
10146                                     
10147 
10148                                             stmts = instantiate(pc,  "FPREM");
10149 
10150                                     
10151 
10152                                     
10153                                     
10154                                     
10155                                     
10156                                     break;
10157                                   case 1: 
10158                                     nextPC = 2 + MATCH_p; 
10159                                     
10160 #line 2116 "frontend/machine/pentium/decoder.m"
10161                                     
10162 
10163                                             stmts = instantiate(pc,  "FYL2XP1");
10164 
10165                                     
10166 
10167                                     
10168                                     
10169                                     
10170                                     
10171                                     break;
10172                                   case 2: 
10173                                     nextPC = 2 + MATCH_p; 
10174                                     
10175 #line 2008 "frontend/machine/pentium/decoder.m"
10176                                     
10177 
10178                                             stmts = instantiate(pc,  "FSQRT");
10179 
10180                                     
10181 
10182                                     
10183                                     
10184                                     
10185                                     
10186                                     break;
10187                                   case 3: 
10188                                     nextPC = 2 + MATCH_p; 
10189                                     
10190 #line 2005 "frontend/machine/pentium/decoder.m"
10191                                     
10192 
10193                                             stmts = instantiate(pc,  "FSINCOS");
10194 
10195                                     
10196 
10197                                     
10198                                     
10199                                     
10200                                     
10201                                     break;
10202                                   case 4: 
10203                                     nextPC = 2 + MATCH_p; 
10204                                     
10205 #line 1990 "frontend/machine/pentium/decoder.m"
10206                                     
10207 
10208                                             stmts = instantiate(pc,  "FRNDINT");
10209 
10210                                     
10211 
10212                                     
10213                                     
10214                                     
10215                                     
10216                                     break;
10217                                   case 5: 
10218                                     nextPC = 2 + MATCH_p; 
10219                                     
10220 #line 1999 "frontend/machine/pentium/decoder.m"
10221                                     
10222 
10223                                             stmts = instantiate(pc,  "FSCALE");
10224 
10225                                     
10226 
10227                                     
10228                                     
10229                                     
10230                                     
10231                                     break;
10232                                   case 6: 
10233                                     nextPC = 2 + MATCH_p; 
10234                                     
10235 #line 2002 "frontend/machine/pentium/decoder.m"
10236                                     
10237 
10238                                             stmts = instantiate(pc,  "FSIN");
10239 
10240                                     
10241 
10242                                     
10243                                     
10244                                     
10245                                     
10246                                     break;
10247                                   case 7: 
10248                                     nextPC = 2 + MATCH_p; 
10249                                     
10250 #line 1832 "frontend/machine/pentium/decoder.m"
10251                                     
10252 
10253                                             stmts = instantiate(pc,  "FCOS");
10254 
10255                                     
10256 
10257                                     
10258                                     
10259                                     
10260                                     
10261                                     break;
10262                                   default: assert(0);
10263                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
10264                               break;
10265                             default: assert(0);
10266                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
10267                         break;
10268                       default: assert(0);
10269                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
10270                   
10271                   break;
10272                 case 2: 
10273                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
10274                   
10275                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
10276                       case 0: 
10277                         
10278                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
10279                             case 0: 
10280                               
10281                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
10282                                   case 0: case 1: case 2: case 3: case 6: 
10283                                   case 7: 
10284                                     { 
10285                                       unsigned Mem32 = 
10286                                         1 + addressToPC(MATCH_p);
10287                                       nextPC = 2 + MATCH_p; 
10288                                       
10289 #line 1775 "frontend/machine/pentium/decoder.m"
10290                                       
10291 
10292                                             stmts = instantiate(pc,  "FIADD.I32", DIS_MEM32);
10293 
10294                                       
10295 
10296                                       
10297                                       
10298                                       
10299                                     }
10300                                     
10301                                     break;
10302                                   case 4: 
10303                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
10304                                     if ((MATCH_w_8_16 & 0x7) 
10305                                             /* base at 16 */ == 5 && 
10306                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10307                                             /* index at 16 */ && 
10308                                       (MATCH_w_8_16 >> 3 & 0x7) 
10309                                             /* index at 16 */ < 8)) 
10310                                       goto MATCH_label_c1119;  /*opt-block+*/
10311                                     else 
10312                                       goto MATCH_label_c1118;  /*opt-block+*/
10313                                     
10314                                     break;
10315                                   case 5: 
10316                                     goto MATCH_label_c1120; break;
10317                                   default: assert(0);
10318                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
10319                               break;
10320                             case 1: 
10321                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
10322                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
10323                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10324                                       /* index at 16 */ && 
10325                                 (MATCH_w_8_16 >> 3 & 0x7) 
10326                                       /* index at 16 */ < 8)) { 
10327                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
10328                                 nextPC = 4 + MATCH_p; 
10329                                 
10330 #line 1775 "frontend/machine/pentium/decoder.m"
10331                                 
10332 
10333                                         stmts = instantiate(pc,  "FIADD.I32", DIS_MEM32);
10334 
10335                                 
10336 
10337                                 
10338                                 
10339                                 
10340                               } /*opt-block*//*opt-block+*/
10341                               else 
10342                                 goto MATCH_label_c1118;  /*opt-block+*/
10343                               
10344                               break;
10345                             case 2: 
10346                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
10347                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
10348                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10349                                       /* index at 16 */ && 
10350                                 (MATCH_w_8_16 >> 3 & 0x7) 
10351                                       /* index at 16 */ < 8)) 
10352                                 goto MATCH_label_c1119;  /*opt-block+*/
10353                               else 
10354                                 goto MATCH_label_c1120;  /*opt-block+*/
10355                               
10356                               break;
10357                             case 3: 
10358                               goto MATCH_label_c64; break;
10359                             default: assert(0);
10360                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
10361                         break;
10362                       case 1: 
10363                         
10364                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
10365                             case 0: 
10366                               
10367                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
10368                                   case 0: case 1: case 2: case 3: case 6: 
10369                                   case 7: 
10370                                     { 
10371                                       unsigned Mem32 = 
10372                                         1 + addressToPC(MATCH_p);
10373                                       nextPC = 2 + MATCH_p; 
10374                                       
10375 #line 1969 "frontend/machine/pentium/decoder.m"
10376                                       
10377 
10378                                             stmts = instantiate(pc,  "FIMUL.I32", DIS_MEM32);
10379 
10380                                       
10381 
10382                                       
10383                                       
10384                                       
10385                                     }
10386                                     
10387                                     break;
10388                                   case 4: 
10389                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
10390                                     if ((MATCH_w_8_16 & 0x7) 
10391                                             /* base at 16 */ == 5 && 
10392                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10393                                             /* index at 16 */ && 
10394                                       (MATCH_w_8_16 >> 3 & 0x7) 
10395                                             /* index at 16 */ < 8)) 
10396                                       goto MATCH_label_c1122;  /*opt-block+*/
10397                                     else 
10398                                       goto MATCH_label_c1121;  /*opt-block+*/
10399                                     
10400                                     break;
10401                                   case 5: 
10402                                     goto MATCH_label_c1123; break;
10403                                   default: assert(0);
10404                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
10405                               break;
10406                             case 1: 
10407                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
10408                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
10409                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10410                                       /* index at 16 */ && 
10411                                 (MATCH_w_8_16 >> 3 & 0x7) 
10412                                       /* index at 16 */ < 8)) { 
10413                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
10414                                 nextPC = 4 + MATCH_p; 
10415                                 
10416 #line 1969 "frontend/machine/pentium/decoder.m"
10417                                 
10418 
10419                                         stmts = instantiate(pc,  "FIMUL.I32", DIS_MEM32);
10420 
10421                                 
10422 
10423                                 
10424                                 
10425                                 
10426                               } /*opt-block*//*opt-block+*/
10427                               else 
10428                                 goto MATCH_label_c1121;  /*opt-block+*/
10429                               
10430                               break;
10431                             case 2: 
10432                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
10433                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
10434                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10435                                       /* index at 16 */ && 
10436                                 (MATCH_w_8_16 >> 3 & 0x7) 
10437                                       /* index at 16 */ < 8)) 
10438                                 goto MATCH_label_c1122;  /*opt-block+*/
10439                               else 
10440                                 goto MATCH_label_c1123;  /*opt-block+*/
10441                               
10442                               break;
10443                             case 3: 
10444                               goto MATCH_label_c64; break;
10445                             default: assert(0);
10446                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
10447                         break;
10448                       case 2: 
10449                         
10450                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
10451                             case 0: 
10452                               
10453                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
10454                                   case 0: case 1: case 2: case 3: case 6: 
10455                                   case 7: 
10456                                     { 
10457                                       unsigned Mem32 = 
10458                                         1 + addressToPC(MATCH_p);
10459                                       nextPC = 2 + MATCH_p; 
10460                                       
10461 #line 1799 "frontend/machine/pentium/decoder.m"
10462                                       
10463 
10464                                             stmts = instantiate(pc,  "FICOM.I32", DIS_MEM32);
10465 
10466                                       
10467 
10468                                       
10469                                       
10470                                       
10471                                     }
10472                                     
10473                                     break;
10474                                   case 4: 
10475                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
10476                                     if ((MATCH_w_8_16 & 0x7) 
10477                                             /* base at 16 */ == 5 && 
10478                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10479                                             /* index at 16 */ && 
10480                                       (MATCH_w_8_16 >> 3 & 0x7) 
10481                                             /* index at 16 */ < 8)) 
10482                                       goto MATCH_label_c1125;  /*opt-block+*/
10483                                     else 
10484                                       goto MATCH_label_c1124;  /*opt-block+*/
10485                                     
10486                                     break;
10487                                   case 5: 
10488                                     goto MATCH_label_c1126; break;
10489                                   default: assert(0);
10490                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
10491                               break;
10492                             case 1: 
10493                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
10494                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
10495                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10496                                       /* index at 16 */ && 
10497                                 (MATCH_w_8_16 >> 3 & 0x7) 
10498                                       /* index at 16 */ < 8)) { 
10499                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
10500                                 nextPC = 4 + MATCH_p; 
10501                                 
10502 #line 1799 "frontend/machine/pentium/decoder.m"
10503                                 
10504 
10505                                         stmts = instantiate(pc,  "FICOM.I32", DIS_MEM32);
10506 
10507                                 
10508 
10509                                 
10510                                 
10511                                 
10512                               } /*opt-block*//*opt-block+*/
10513                               else 
10514                                 goto MATCH_label_c1124;  /*opt-block+*/
10515                               
10516                               break;
10517                             case 2: 
10518                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
10519                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
10520                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10521                                       /* index at 16 */ && 
10522                                 (MATCH_w_8_16 >> 3 & 0x7) 
10523                                       /* index at 16 */ < 8)) 
10524                                 goto MATCH_label_c1125;  /*opt-block+*/
10525                               else 
10526                                 goto MATCH_label_c1126;  /*opt-block+*/
10527                               
10528                               break;
10529                             case 3: 
10530                               goto MATCH_label_c64; break;
10531                             default: assert(0);
10532                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
10533                         break;
10534                       case 3: 
10535                         
10536                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
10537                             case 0: 
10538                               
10539                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
10540                                   case 0: case 1: case 2: case 3: case 6: 
10541                                   case 7: 
10542                                     { 
10543                                       unsigned Mem32 = 
10544                                         1 + addressToPC(MATCH_p);
10545                                       nextPC = 2 + MATCH_p; 
10546                                       
10547 #line 1817 "frontend/machine/pentium/decoder.m"
10548                                       
10549 
10550                                             stmts = instantiate(pc,  "FICOMP.I32", DIS_MEM32);
10551 
10552                                       
10553 
10554                                       
10555                                       
10556                                       
10557                                     }
10558                                     
10559                                     break;
10560                                   case 4: 
10561                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
10562                                     if ((MATCH_w_8_16 & 0x7) 
10563                                             /* base at 16 */ == 5 && 
10564                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10565                                             /* index at 16 */ && 
10566                                       (MATCH_w_8_16 >> 3 & 0x7) 
10567                                             /* index at 16 */ < 8)) 
10568                                       goto MATCH_label_c1128;  /*opt-block+*/
10569                                     else 
10570                                       goto MATCH_label_c1127;  /*opt-block+*/
10571                                     
10572                                     break;
10573                                   case 5: 
10574                                     goto MATCH_label_c1129; break;
10575                                   default: assert(0);
10576                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
10577                               break;
10578                             case 1: 
10579                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
10580                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
10581                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10582                                       /* index at 16 */ && 
10583                                 (MATCH_w_8_16 >> 3 & 0x7) 
10584                                       /* index at 16 */ < 8)) { 
10585                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
10586                                 nextPC = 4 + MATCH_p; 
10587                                 
10588 #line 1817 "frontend/machine/pentium/decoder.m"
10589                                 
10590 
10591                                         stmts = instantiate(pc,  "FICOMP.I32", DIS_MEM32);
10592 
10593                                 
10594 
10595                                 
10596                                 
10597                                 
10598                               } /*opt-block*//*opt-block+*/
10599                               else 
10600                                 goto MATCH_label_c1127;  /*opt-block+*/
10601                               
10602                               break;
10603                             case 2: 
10604                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
10605                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
10606                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10607                                       /* index at 16 */ && 
10608                                 (MATCH_w_8_16 >> 3 & 0x7) 
10609                                       /* index at 16 */ < 8)) 
10610                                 goto MATCH_label_c1128;  /*opt-block+*/
10611                               else 
10612                                 goto MATCH_label_c1129;  /*opt-block+*/
10613                               
10614                               break;
10615                             case 3: 
10616                               goto MATCH_label_c64; break;
10617                             default: assert(0);
10618                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
10619                         break;
10620                       case 4: 
10621                         
10622                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
10623                             case 0: 
10624                               
10625                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
10626                                   case 0: case 1: case 2: case 3: case 6: 
10627                                   case 7: 
10628                                     { 
10629                                       unsigned Mem32 = 
10630                                         1 + addressToPC(MATCH_p);
10631                                       nextPC = 2 + MATCH_p; 
10632                                       
10633 #line 2056 "frontend/machine/pentium/decoder.m"
10634                                       
10635 
10636                                             stmts = instantiate(pc,  "FISUB.I32", DIS_MEM32);
10637 
10638                                       
10639 
10640                                       
10641                                       
10642                                       
10643                                     }
10644                                     
10645                                     break;
10646                                   case 4: 
10647                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
10648                                     if ((MATCH_w_8_16 & 0x7) 
10649                                             /* base at 16 */ == 5 && 
10650                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10651                                             /* index at 16 */ && 
10652                                       (MATCH_w_8_16 >> 3 & 0x7) 
10653                                             /* index at 16 */ < 8)) 
10654                                       goto MATCH_label_c1131;  /*opt-block+*/
10655                                     else 
10656                                       goto MATCH_label_c1130;  /*opt-block+*/
10657                                     
10658                                     break;
10659                                   case 5: 
10660                                     goto MATCH_label_c1132; break;
10661                                   default: assert(0);
10662                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
10663                               break;
10664                             case 1: 
10665                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
10666                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
10667                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10668                                       /* index at 16 */ && 
10669                                 (MATCH_w_8_16 >> 3 & 0x7) 
10670                                       /* index at 16 */ < 8)) { 
10671                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
10672                                 nextPC = 4 + MATCH_p; 
10673                                 
10674 #line 2056 "frontend/machine/pentium/decoder.m"
10675                                 
10676 
10677                                         stmts = instantiate(pc,  "FISUB.I32", DIS_MEM32);
10678 
10679                                 
10680 
10681                                 
10682                                 
10683                                 
10684                               } /*opt-block*//*opt-block+*/
10685                               else 
10686                                 goto MATCH_label_c1130;  /*opt-block+*/
10687                               
10688                               break;
10689                             case 2: 
10690                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
10691                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
10692                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10693                                       /* index at 16 */ && 
10694                                 (MATCH_w_8_16 >> 3 & 0x7) 
10695                                       /* index at 16 */ < 8)) 
10696                                 goto MATCH_label_c1131;  /*opt-block+*/
10697                               else 
10698                                 goto MATCH_label_c1132;  /*opt-block+*/
10699                               
10700                               break;
10701                             case 3: 
10702                               goto MATCH_label_c64; break;
10703                             default: assert(0);
10704                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
10705                         break;
10706                       case 5: 
10707                         
10708                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
10709                             case 0: 
10710                               
10711                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
10712                                   case 0: case 1: case 2: case 3: case 6: 
10713                                   case 7: 
10714                                     { 
10715                                       unsigned Mem32 = 
10716                                         1 + addressToPC(MATCH_p);
10717                                       nextPC = 2 + MATCH_p; 
10718                                       
10719 #line 2077 "frontend/machine/pentium/decoder.m"
10720                                       
10721 
10722                                             stmts = instantiate(pc,  "FISUBR.I32", DIS_MEM32);
10723 
10724                                       
10725 
10726                                       
10727                                       
10728                                       
10729                                     }
10730                                     
10731                                     break;
10732                                   case 4: 
10733                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
10734                                     if ((MATCH_w_8_16 & 0x7) 
10735                                             /* base at 16 */ == 5 && 
10736                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10737                                             /* index at 16 */ && 
10738                                       (MATCH_w_8_16 >> 3 & 0x7) 
10739                                             /* index at 16 */ < 8)) 
10740                                       goto MATCH_label_c1134;  /*opt-block+*/
10741                                     else 
10742                                       goto MATCH_label_c1133;  /*opt-block+*/
10743                                     
10744                                     break;
10745                                   case 5: 
10746                                     goto MATCH_label_c1135; break;
10747                                   default: assert(0);
10748                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
10749                               break;
10750                             case 1: 
10751                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
10752                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
10753                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10754                                       /* index at 16 */ && 
10755                                 (MATCH_w_8_16 >> 3 & 0x7) 
10756                                       /* index at 16 */ < 8)) { 
10757                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
10758                                 nextPC = 4 + MATCH_p; 
10759                                 
10760 #line 2077 "frontend/machine/pentium/decoder.m"
10761                                 
10762 
10763                                         stmts = instantiate(pc,  "FISUBR.I32", DIS_MEM32);
10764 
10765                                 
10766 
10767                                 
10768                                 
10769                                 
10770                               } /*opt-block*//*opt-block+*/
10771                               else 
10772                                 goto MATCH_label_c1133;  /*opt-block+*/
10773                               
10774                               break;
10775                             case 2: 
10776                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
10777                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
10778                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10779                                       /* index at 16 */ && 
10780                                 (MATCH_w_8_16 >> 3 & 0x7) 
10781                                       /* index at 16 */ < 8)) 
10782                                 goto MATCH_label_c1134;  /*opt-block+*/
10783                               else 
10784                                 goto MATCH_label_c1135;  /*opt-block+*/
10785                               
10786                               break;
10787                             case 3: 
10788                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 1) { 
10789                                 nextPC = 2 + MATCH_p; 
10790                                 
10791 #line 2095 "frontend/machine/pentium/decoder.m"
10792                                 
10793 
10794                                         stmts = instantiate(pc,  "FUCOMPP");
10795 
10796                                 
10797 
10798                                 
10799                                 
10800                                 
10801                               } /*opt-block*//*opt-block+*/
10802                               else 
10803                                 goto MATCH_label_c64;  /*opt-block+*/
10804                               
10805                               break;
10806                             default: assert(0);
10807                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
10808                         break;
10809                       case 6: 
10810                         
10811                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
10812                             case 0: 
10813                               
10814                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
10815                                   case 0: case 1: case 2: case 3: case 6: 
10816                                   case 7: 
10817                                     { 
10818                                       unsigned Mem32 = 
10819                                         1 + addressToPC(MATCH_p);
10820                                       nextPC = 2 + MATCH_p; 
10821                                       
10822 #line 1853 "frontend/machine/pentium/decoder.m"
10823                                       
10824 
10825                                             stmts = instantiate(pc,  "FIDIV.I32", DIS_MEM32);
10826 
10827                                       
10828 
10829                                       
10830                                       
10831                                       
10832                                     }
10833                                     
10834                                     break;
10835                                   case 4: 
10836                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
10837                                     if ((MATCH_w_8_16 & 0x7) 
10838                                             /* base at 16 */ == 5 && 
10839                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10840                                             /* index at 16 */ && 
10841                                       (MATCH_w_8_16 >> 3 & 0x7) 
10842                                             /* index at 16 */ < 8)) 
10843                                       goto MATCH_label_c1137;  /*opt-block+*/
10844                                     else 
10845                                       goto MATCH_label_c1136;  /*opt-block+*/
10846                                     
10847                                     break;
10848                                   case 5: 
10849                                     goto MATCH_label_c1138; break;
10850                                   default: assert(0);
10851                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
10852                               break;
10853                             case 1: 
10854                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
10855                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
10856                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10857                                       /* index at 16 */ && 
10858                                 (MATCH_w_8_16 >> 3 & 0x7) 
10859                                       /* index at 16 */ < 8)) { 
10860                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
10861                                 nextPC = 4 + MATCH_p; 
10862                                 
10863 #line 1853 "frontend/machine/pentium/decoder.m"
10864                                 
10865 
10866                                         stmts = instantiate(pc,  "FIDIV.I32", DIS_MEM32);
10867 
10868                                 
10869 
10870                                 
10871                                 
10872                                 
10873                               } /*opt-block*//*opt-block+*/
10874                               else 
10875                                 goto MATCH_label_c1136;  /*opt-block+*/
10876                               
10877                               break;
10878                             case 2: 
10879                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
10880                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
10881                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10882                                       /* index at 16 */ && 
10883                                 (MATCH_w_8_16 >> 3 & 0x7) 
10884                                       /* index at 16 */ < 8)) 
10885                                 goto MATCH_label_c1137;  /*opt-block+*/
10886                               else 
10887                                 goto MATCH_label_c1138;  /*opt-block+*/
10888                               
10889                               break;
10890                             case 3: 
10891                               goto MATCH_label_c64; break;
10892                             default: assert(0);
10893                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
10894                         break;
10895                       case 7: 
10896                         
10897                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
10898                             case 0: 
10899                               
10900                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
10901                                   case 0: case 1: case 2: case 3: case 6: 
10902                                   case 7: 
10903                                     { 
10904                                       unsigned Mem32 = 
10905                                         1 + addressToPC(MATCH_p);
10906                                       nextPC = 2 + MATCH_p; 
10907                                       
10908 #line 1871 "frontend/machine/pentium/decoder.m"
10909                                       
10910 
10911                                             stmts = instantiate(pc,  "FIDIVR.I32", DIS_MEM32);
10912 
10913                                       
10914 
10915                                       
10916                                       
10917                                       
10918                                     }
10919                                     
10920                                     break;
10921                                   case 4: 
10922                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
10923                                     if ((MATCH_w_8_16 & 0x7) 
10924                                             /* base at 16 */ == 5 && 
10925                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10926                                             /* index at 16 */ && 
10927                                       (MATCH_w_8_16 >> 3 & 0x7) 
10928                                             /* index at 16 */ < 8)) 
10929                                       goto MATCH_label_c1140;  /*opt-block+*/
10930                                     else 
10931                                       goto MATCH_label_c1139;  /*opt-block+*/
10932                                     
10933                                     break;
10934                                   case 5: 
10935                                     goto MATCH_label_c1141; break;
10936                                   default: assert(0);
10937                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
10938                               break;
10939                             case 1: 
10940                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
10941                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
10942                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10943                                       /* index at 16 */ && 
10944                                 (MATCH_w_8_16 >> 3 & 0x7) 
10945                                       /* index at 16 */ < 8)) { 
10946                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
10947                                 nextPC = 4 + MATCH_p; 
10948                                 
10949 #line 1871 "frontend/machine/pentium/decoder.m"
10950                                 
10951 
10952                                         stmts = instantiate(pc,  "FIDIVR.I32", DIS_MEM32);
10953 
10954                                 
10955 
10956                                 
10957                                 
10958                                 
10959                               } /*opt-block*//*opt-block+*/
10960                               else 
10961                                 goto MATCH_label_c1139;  /*opt-block+*/
10962                               
10963                               break;
10964                             case 2: 
10965                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
10966                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
10967                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
10968                                       /* index at 16 */ && 
10969                                 (MATCH_w_8_16 >> 3 & 0x7) 
10970                                       /* index at 16 */ < 8)) 
10971                                 goto MATCH_label_c1140;  /*opt-block+*/
10972                               else 
10973                                 goto MATCH_label_c1141;  /*opt-block+*/
10974                               
10975                               break;
10976                             case 3: 
10977                               goto MATCH_label_c64; break;
10978                             default: assert(0);
10979                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
10980                         break;
10981                       default: assert(0);
10982                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
10983                   
10984                   break;
10985                 case 3: 
10986                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
10987                   
10988                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
10989                       case 0: 
10990                         
10991                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
10992                             case 0: 
10993                               
10994                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
10995                                   case 0: case 1: case 2: case 3: case 6: 
10996                                   case 7: 
10997                                     { 
10998                                       unsigned Mem32 = 
10999                                         1 + addressToPC(MATCH_p);
11000                                       nextPC = 2 + MATCH_p; 
11001                                       
11002 #line 1886 "frontend/machine/pentium/decoder.m"
11003                                       
11004 
11005                                             stmts = instantiate(pc,  "FILD.lsI32", DIS_MEM32);
11006 
11007                                       
11008 
11009                                       
11010                                       
11011                                       
11012                                     }
11013                                     
11014                                     break;
11015                                   case 4: 
11016                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
11017                                     if ((MATCH_w_8_16 & 0x7) 
11018                                             /* base at 16 */ == 5 && 
11019                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11020                                             /* index at 16 */ && 
11021                                       (MATCH_w_8_16 >> 3 & 0x7) 
11022                                             /* index at 16 */ < 8)) 
11023                                       goto MATCH_label_c1143;  /*opt-block+*/
11024                                     else 
11025                                       goto MATCH_label_c1142;  /*opt-block+*/
11026                                     
11027                                     break;
11028                                   case 5: 
11029                                     goto MATCH_label_c1144; break;
11030                                   default: assert(0);
11031                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
11032                               break;
11033                             case 1: 
11034                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11035                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11036                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11037                                       /* index at 16 */ && 
11038                                 (MATCH_w_8_16 >> 3 & 0x7) 
11039                                       /* index at 16 */ < 8)) { 
11040                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
11041                                 nextPC = 4 + MATCH_p; 
11042                                 
11043 #line 1886 "frontend/machine/pentium/decoder.m"
11044                                 
11045 
11046                                         stmts = instantiate(pc,  "FILD.lsI32", DIS_MEM32);
11047 
11048                                 
11049 
11050                                 
11051                                 
11052                                 
11053                               } /*opt-block*//*opt-block+*/
11054                               else 
11055                                 goto MATCH_label_c1142;  /*opt-block+*/
11056                               
11057                               break;
11058                             case 2: 
11059                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11060                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11061                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11062                                       /* index at 16 */ && 
11063                                 (MATCH_w_8_16 >> 3 & 0x7) 
11064                                       /* index at 16 */ < 8)) 
11065                                 goto MATCH_label_c1143;  /*opt-block+*/
11066                               else 
11067                                 goto MATCH_label_c1144;  /*opt-block+*/
11068                               
11069                               break;
11070                             case 3: 
11071                               goto MATCH_label_c64; break;
11072                             default: assert(0);
11073                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
11074                         break;
11075                       case 1: 
11076                         goto MATCH_label_c64; break;
11077                       case 2: 
11078                         
11079                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
11080                             case 0: 
11081                               
11082                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
11083                                   case 0: case 1: case 2: case 3: case 6: 
11084                                   case 7: 
11085                                     { 
11086                                       unsigned Mem32 = 
11087                                         1 + addressToPC(MATCH_p);
11088                                       nextPC = 2 + MATCH_p; 
11089                                       
11090 #line 1898 "frontend/machine/pentium/decoder.m"
11091                                       
11092 
11093                                             stmts = instantiate(pc,  "FIST.lsI32", DIS_MEM32);
11094 
11095                                       
11096 
11097                                       
11098                                       
11099                                       
11100                                     }
11101                                     
11102                                     break;
11103                                   case 4: 
11104                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
11105                                     if ((MATCH_w_8_16 & 0x7) 
11106                                             /* base at 16 */ == 5 && 
11107                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11108                                             /* index at 16 */ && 
11109                                       (MATCH_w_8_16 >> 3 & 0x7) 
11110                                             /* index at 16 */ < 8)) 
11111                                       goto MATCH_label_c1146;  /*opt-block+*/
11112                                     else 
11113                                       goto MATCH_label_c1145;  /*opt-block+*/
11114                                     
11115                                     break;
11116                                   case 5: 
11117                                     goto MATCH_label_c1147; break;
11118                                   default: assert(0);
11119                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
11120                               break;
11121                             case 1: 
11122                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11123                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11124                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11125                                       /* index at 16 */ && 
11126                                 (MATCH_w_8_16 >> 3 & 0x7) 
11127                                       /* index at 16 */ < 8)) { 
11128                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
11129                                 nextPC = 4 + MATCH_p; 
11130                                 
11131 #line 1898 "frontend/machine/pentium/decoder.m"
11132                                 
11133 
11134                                         stmts = instantiate(pc,  "FIST.lsI32", DIS_MEM32);
11135 
11136                                 
11137 
11138                                 
11139                                 
11140                                 
11141                               } /*opt-block*//*opt-block+*/
11142                               else 
11143                                 goto MATCH_label_c1145;  /*opt-block+*/
11144                               
11145                               break;
11146                             case 2: 
11147                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11148                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11149                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11150                                       /* index at 16 */ && 
11151                                 (MATCH_w_8_16 >> 3 & 0x7) 
11152                                       /* index at 16 */ < 8)) 
11153                                 goto MATCH_label_c1146;  /*opt-block+*/
11154                               else 
11155                                 goto MATCH_label_c1147;  /*opt-block+*/
11156                               
11157                               break;
11158                             case 3: 
11159                               goto MATCH_label_c64; break;
11160                             default: assert(0);
11161                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
11162                         break;
11163                       case 3: 
11164                         
11165                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
11166                             case 0: 
11167                               
11168                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
11169                                   case 0: case 1: case 2: case 3: case 6: 
11170                                   case 7: 
11171                                     { 
11172                                       unsigned Mem32 = 
11173                                         1 + addressToPC(MATCH_p);
11174                                       nextPC = 2 + MATCH_p; 
11175                                       
11176 #line 1904 "frontend/machine/pentium/decoder.m"
11177                                       
11178 
11179                                             stmts = instantiate(pc,  "FISTP.lsI32", DIS_MEM32);
11180 
11181                                       
11182 
11183                                       
11184                                       
11185                                       
11186                                     }
11187                                     
11188                                     break;
11189                                   case 4: 
11190                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
11191                                     if ((MATCH_w_8_16 & 0x7) 
11192                                             /* base at 16 */ == 5 && 
11193                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11194                                             /* index at 16 */ && 
11195                                       (MATCH_w_8_16 >> 3 & 0x7) 
11196                                             /* index at 16 */ < 8)) 
11197                                       goto MATCH_label_c1149;  /*opt-block+*/
11198                                     else 
11199                                       goto MATCH_label_c1148;  /*opt-block+*/
11200                                     
11201                                     break;
11202                                   case 5: 
11203                                     goto MATCH_label_c1150; break;
11204                                   default: assert(0);
11205                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
11206                               break;
11207                             case 1: 
11208                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11209                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11210                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11211                                       /* index at 16 */ && 
11212                                 (MATCH_w_8_16 >> 3 & 0x7) 
11213                                       /* index at 16 */ < 8)) { 
11214                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
11215                                 nextPC = 4 + MATCH_p; 
11216                                 
11217 #line 1904 "frontend/machine/pentium/decoder.m"
11218                                 
11219 
11220                                         stmts = instantiate(pc,  "FISTP.lsI32", DIS_MEM32);
11221 
11222                                 
11223 
11224                                 
11225                                 
11226                                 
11227                               } /*opt-block*//*opt-block+*/
11228                               else 
11229                                 goto MATCH_label_c1148;  /*opt-block+*/
11230                               
11231                               break;
11232                             case 2: 
11233                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11234                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11235                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11236                                       /* index at 16 */ && 
11237                                 (MATCH_w_8_16 >> 3 & 0x7) 
11238                                       /* index at 16 */ < 8)) 
11239                                 goto MATCH_label_c1149;  /*opt-block+*/
11240                               else 
11241                                 goto MATCH_label_c1150;  /*opt-block+*/
11242                               
11243                               break;
11244                             case 3: 
11245                               goto MATCH_label_c64; break;
11246                             default: assert(0);
11247                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
11248                         break;
11249                       case 4: 
11250                         
11251                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
11252                             case 0: case 1: case 4: case 5: case 6: case 7: 
11253                               goto MATCH_label_c64; break;
11254                             case 2: 
11255                               if ((MATCH_w_8_8 >> 6 & 0x3) 
11256                                       /* mod at 8 */ == 3) { 
11257                                 nextPC = 2 + MATCH_p; 
11258                                 
11259 #line 1790 "frontend/machine/pentium/decoder.m"
11260                                 
11261 
11262                                         stmts = instantiate(pc,  "FNCLEX");
11263 
11264                                 
11265 
11266                                 
11267                                 
11268                                 
11269                               } /*opt-block*//*opt-block+*/
11270                               else 
11271                                 goto MATCH_label_c64;  /*opt-block+*/
11272                               
11273                               break;
11274                             case 3: 
11275                               if ((MATCH_w_8_8 >> 6 & 0x3) 
11276                                       /* mod at 8 */ == 3) { 
11277                                 nextPC = 2 + MATCH_p; 
11278                                 
11279 #line 1892 "frontend/machine/pentium/decoder.m"
11280                                 
11281 
11282                                         stmts = instantiate(pc,  "FINIT");
11283 
11284                                 
11285 
11286                                 
11287                                 
11288                                 
11289                               } /*opt-block*//*opt-block+*/
11290                               else 
11291                                 goto MATCH_label_c64;  /*opt-block+*/
11292                               
11293                               break;
11294                             default: assert(0);
11295                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
11296                         break;
11297                       case 5: 
11298                         
11299                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
11300                             case 0: 
11301                               
11302                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
11303                                   case 0: case 1: case 2: case 3: case 6: 
11304                                   case 7: 
11305                                     { 
11306                                       unsigned Mem80 = 
11307                                         1 + addressToPC(MATCH_p);
11308                                       nextPC = 2 + MATCH_p; 
11309                                       
11310 #line 1916 "frontend/machine/pentium/decoder.m"
11311                                       
11312 
11313                                             stmts = instantiate(pc,  "FLD80", DIS_MEM80);
11314 
11315                                       
11316 
11317                                       /* This is a bit tricky. The FPUSH logically comes between the read of STi and
11318 
11319                                       # the write to ST0. In particular, FLD ST0 is supposed to duplicate the TOS.
11320 
11321                                       # This problem only happens with this load instruction, so there is a work
11322 
11323                                       # around here that gives us the SSL a value of i that is one more than in
11324 
11325                                       # the instruction */
11326 
11327                                       
11328                                       
11329                                       
11330                                     }
11331                                     
11332                                     break;
11333                                   case 4: 
11334                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
11335                                     if ((MATCH_w_8_16 & 0x7) 
11336                                             /* base at 16 */ == 5 && 
11337                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11338                                             /* index at 16 */ && 
11339                                       (MATCH_w_8_16 >> 3 & 0x7) 
11340                                             /* index at 16 */ < 8)) 
11341                                       goto MATCH_label_c1152;  /*opt-block+*/
11342                                     else 
11343                                       goto MATCH_label_c1151;  /*opt-block+*/
11344                                     
11345                                     break;
11346                                   case 5: 
11347                                     goto MATCH_label_c1153; break;
11348                                   default: assert(0);
11349                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
11350                               break;
11351                             case 1: 
11352                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11353                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11354                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11355                                       /* index at 16 */ && 
11356                                 (MATCH_w_8_16 >> 3 & 0x7) 
11357                                       /* index at 16 */ < 8)) { 
11358                                 unsigned Mem80 = 1 + addressToPC(MATCH_p);
11359                                 nextPC = 4 + MATCH_p; 
11360                                 
11361 #line 1916 "frontend/machine/pentium/decoder.m"
11362                                 
11363 
11364                                         stmts = instantiate(pc,  "FLD80", DIS_MEM80);
11365 
11366                                 
11367 
11368                                 /* This is a bit tricky. The FPUSH logically comes between the read of STi and
11369 
11370                                 # the write to ST0. In particular, FLD ST0 is supposed to duplicate the TOS.
11371 
11372                                 # This problem only happens with this load instruction, so there is a work
11373 
11374                                 # around here that gives us the SSL a value of i that is one more than in
11375 
11376                                 # the instruction */
11377 
11378                                 
11379                                 
11380                                 
11381                               } /*opt-block*//*opt-block+*/
11382                               else 
11383                                 goto MATCH_label_c1151;  /*opt-block+*/
11384                               
11385                               break;
11386                             case 2: 
11387                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11388                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11389                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11390                                       /* index at 16 */ && 
11391                                 (MATCH_w_8_16 >> 3 & 0x7) 
11392                                       /* index at 16 */ < 8)) 
11393                                 goto MATCH_label_c1152;  /*opt-block+*/
11394                               else 
11395                                 goto MATCH_label_c1153;  /*opt-block+*/
11396                               
11397                               break;
11398                             case 3: 
11399                               MATCH_name = "FUCOMI.ST.STi"; 
11400                               { 
11401                                 char *name = MATCH_name;
11402                                 unsigned idx = 
11403                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
11404                                 nextPC = 2 + MATCH_p; 
11405                                 
11406 #line 2098 "frontend/machine/pentium/decoder.m"
11407                                 
11408 
11409                                         stmts = instantiate(pc, name, DIS_IDX);
11410 
11411                                 
11412 
11413                                 
11414                                 
11415                                 
11416                               }
11417                               
11418                               break;
11419                             default: assert(0);
11420                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
11421                         break;
11422                       case 6: 
11423                         if ((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */ == 3) { 
11424                           MATCH_name = "FCOMI.ST.STi"; 
11425                           { 
11426                             char *name = MATCH_name;
11427                             unsigned idx = (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
11428                             nextPC = 2 + MATCH_p; 
11429                             
11430 #line 1826 "frontend/machine/pentium/decoder.m"
11431                             
11432 
11433                                     stmts = instantiate(pc, name, DIS_IDX);
11434 
11435                             
11436 
11437                             
11438                             
11439                             
11440                           }
11441                           
11442                         } /*opt-block*/
11443                         else 
11444                           goto MATCH_label_c64;  /*opt-block+*/
11445                         
11446                         break;
11447                       case 7: 
11448                         
11449                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
11450                             case 0: 
11451                               
11452                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
11453                                   case 0: case 1: case 2: case 3: case 6: 
11454                                   case 7: 
11455                                     { 
11456                                       unsigned Mem80 = 
11457                                         1 + addressToPC(MATCH_p);
11458                                       nextPC = 2 + MATCH_p; 
11459                                       
11460 #line 2023 "frontend/machine/pentium/decoder.m"
11461                                       
11462 
11463                                             stmts = instantiate(pc,  "FSTP80", DIS_MEM80);
11464 
11465                                       
11466 
11467                                       
11468                                       
11469                                       
11470                                     }
11471                                     
11472                                     break;
11473                                   case 4: 
11474                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
11475                                     if ((MATCH_w_8_16 & 0x7) 
11476                                             /* base at 16 */ == 5 && 
11477                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11478                                             /* index at 16 */ && 
11479                                       (MATCH_w_8_16 >> 3 & 0x7) 
11480                                             /* index at 16 */ < 8)) 
11481                                       goto MATCH_label_c1155;  /*opt-block+*/
11482                                     else 
11483                                       goto MATCH_label_c1154;  /*opt-block+*/
11484                                     
11485                                     break;
11486                                   case 5: 
11487                                     goto MATCH_label_c1156; break;
11488                                   default: assert(0);
11489                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
11490                               break;
11491                             case 1: 
11492                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11493                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11494                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11495                                       /* index at 16 */ && 
11496                                 (MATCH_w_8_16 >> 3 & 0x7) 
11497                                       /* index at 16 */ < 8)) { 
11498                                 unsigned Mem80 = 1 + addressToPC(MATCH_p);
11499                                 nextPC = 4 + MATCH_p; 
11500                                 
11501 #line 2023 "frontend/machine/pentium/decoder.m"
11502                                 
11503 
11504                                         stmts = instantiate(pc,  "FSTP80", DIS_MEM80);
11505 
11506                                 
11507 
11508                                 
11509                                 
11510                                 
11511                               } /*opt-block*//*opt-block+*/
11512                               else 
11513                                 goto MATCH_label_c1154;  /*opt-block+*/
11514                               
11515                               break;
11516                             case 2: 
11517                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11518                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11519                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11520                                       /* index at 16 */ && 
11521                                 (MATCH_w_8_16 >> 3 & 0x7) 
11522                                       /* index at 16 */ < 8)) 
11523                                 goto MATCH_label_c1155;  /*opt-block+*/
11524                               else 
11525                                 goto MATCH_label_c1156;  /*opt-block+*/
11526                               
11527                               break;
11528                             case 3: 
11529                               goto MATCH_label_c64; break;
11530                             default: assert(0);
11531                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
11532                         break;
11533                       default: assert(0);
11534                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
11535                   
11536                   break;
11537                 case 4: 
11538                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
11539                   
11540                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
11541                       case 0: 
11542                         
11543                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
11544                             case 0: 
11545                               
11546                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
11547                                   case 0: case 1: case 2: case 3: case 6: 
11548                                   case 7: 
11549                                     { 
11550                                       unsigned Mem64 = 
11551                                         1 + addressToPC(MATCH_p);
11552                                       nextPC = 2 + MATCH_p; 
11553                                       
11554 #line 1763 "frontend/machine/pentium/decoder.m"
11555                                       
11556 
11557                                             stmts = instantiate(pc,  "FADD.R64", DIS_MEM64);
11558 
11559                                       
11560 
11561                                       
11562                                       
11563                                       
11564                                     }
11565                                     
11566                                     break;
11567                                   case 4: 
11568                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
11569                                     if ((MATCH_w_8_16 & 0x7) 
11570                                             /* base at 16 */ == 5 && 
11571                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11572                                             /* index at 16 */ && 
11573                                       (MATCH_w_8_16 >> 3 & 0x7) 
11574                                             /* index at 16 */ < 8)) 
11575                                       goto MATCH_label_c1158;  /*opt-block+*/
11576                                     else 
11577                                       goto MATCH_label_c1157;  /*opt-block+*/
11578                                     
11579                                     break;
11580                                   case 5: 
11581                                     goto MATCH_label_c1159; break;
11582                                   default: assert(0);
11583                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
11584                               break;
11585                             case 1: 
11586                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11587                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11588                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11589                                       /* index at 16 */ && 
11590                                 (MATCH_w_8_16 >> 3 & 0x7) 
11591                                       /* index at 16 */ < 8)) { 
11592                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
11593                                 nextPC = 4 + MATCH_p; 
11594                                 
11595 #line 1763 "frontend/machine/pentium/decoder.m"
11596                                 
11597 
11598                                         stmts = instantiate(pc,  "FADD.R64", DIS_MEM64);
11599 
11600                                 
11601 
11602                                 
11603                                 
11604                                 
11605                               } /*opt-block*//*opt-block+*/
11606                               else 
11607                                 goto MATCH_label_c1157;  /*opt-block+*/
11608                               
11609                               break;
11610                             case 2: 
11611                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11612                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11613                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11614                                       /* index at 16 */ && 
11615                                 (MATCH_w_8_16 >> 3 & 0x7) 
11616                                       /* index at 16 */ < 8)) 
11617                                 goto MATCH_label_c1158;  /*opt-block+*/
11618                               else 
11619                                 goto MATCH_label_c1159;  /*opt-block+*/
11620                               
11621                               break;
11622                             case 3: 
11623                               { 
11624                                 unsigned idx = 
11625                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
11626                                 nextPC = 2 + MATCH_p; 
11627                                 
11628 #line 1769 "frontend/machine/pentium/decoder.m"
11629                                 
11630 
11631                                         stmts = instantiate(pc,  "FADD.STi.ST", DIS_IDX);
11632 
11633                                 
11634 
11635                                 
11636                                 
11637                                 
11638                               }
11639                               
11640                               break;
11641                             default: assert(0);
11642                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
11643                         break;
11644                       case 1: 
11645                         
11646                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
11647                             case 0: 
11648                               
11649                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
11650                                   case 0: case 1: case 2: case 3: case 6: 
11651                                   case 7: 
11652                                     { 
11653                                       unsigned Mem64 = 
11654                                         1 + addressToPC(MATCH_p);
11655                                       nextPC = 2 + MATCH_p; 
11656                                       
11657 #line 1957 "frontend/machine/pentium/decoder.m"
11658                                       
11659 
11660                                             stmts = instantiate(pc,  "FMUL.R64", DIS_MEM64);
11661 
11662                                       
11663 
11664                                       
11665                                       
11666                                       
11667                                     }
11668                                     
11669                                     break;
11670                                   case 4: 
11671                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
11672                                     if ((MATCH_w_8_16 & 0x7) 
11673                                             /* base at 16 */ == 5 && 
11674                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11675                                             /* index at 16 */ && 
11676                                       (MATCH_w_8_16 >> 3 & 0x7) 
11677                                             /* index at 16 */ < 8)) 
11678                                       goto MATCH_label_c1161;  /*opt-block+*/
11679                                     else 
11680                                       goto MATCH_label_c1160;  /*opt-block+*/
11681                                     
11682                                     break;
11683                                   case 5: 
11684                                     goto MATCH_label_c1162; break;
11685                                   default: assert(0);
11686                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
11687                               break;
11688                             case 1: 
11689                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11690                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11691                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11692                                       /* index at 16 */ && 
11693                                 (MATCH_w_8_16 >> 3 & 0x7) 
11694                                       /* index at 16 */ < 8)) { 
11695                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
11696                                 nextPC = 4 + MATCH_p; 
11697                                 
11698 #line 1957 "frontend/machine/pentium/decoder.m"
11699                                 
11700 
11701                                         stmts = instantiate(pc,  "FMUL.R64", DIS_MEM64);
11702 
11703                                 
11704 
11705                                 
11706                                 
11707                                 
11708                               } /*opt-block*//*opt-block+*/
11709                               else 
11710                                 goto MATCH_label_c1160;  /*opt-block+*/
11711                               
11712                               break;
11713                             case 2: 
11714                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11715                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11716                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11717                                       /* index at 16 */ && 
11718                                 (MATCH_w_8_16 >> 3 & 0x7) 
11719                                       /* index at 16 */ < 8)) 
11720                                 goto MATCH_label_c1161;  /*opt-block+*/
11721                               else 
11722                                 goto MATCH_label_c1162;  /*opt-block+*/
11723                               
11724                               break;
11725                             case 3: 
11726                               { 
11727                                 unsigned idx = 
11728                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
11729                                 nextPC = 2 + MATCH_p; 
11730                                 
11731 #line 1963 "frontend/machine/pentium/decoder.m"
11732                                 
11733 
11734                                         stmts = instantiate(pc,  "FMUL.STi.ST", DIS_IDX);
11735 
11736                                 
11737 
11738                                 
11739                                 
11740                                 
11741                               }
11742                               
11743                               break;
11744                             default: assert(0);
11745                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
11746                         break;
11747                       case 2: 
11748                         
11749                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
11750                             case 0: 
11751                               
11752                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
11753                                   case 0: case 1: case 2: case 3: case 6: 
11754                                   case 7: 
11755                                     { 
11756                                       unsigned Mem64 = 
11757                                         1 + addressToPC(MATCH_p);
11758                                       nextPC = 2 + MATCH_p; 
11759                                       
11760 #line 1796 "frontend/machine/pentium/decoder.m"
11761                                       
11762 
11763                                             stmts = instantiate(pc,  "FCOM.R64", DIS_MEM64);
11764 
11765                                       
11766 
11767                                       
11768                                       
11769                                       
11770                                     }
11771                                     
11772                                     break;
11773                                   case 4: 
11774                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
11775                                     if ((MATCH_w_8_16 & 0x7) 
11776                                             /* base at 16 */ == 5 && 
11777                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11778                                             /* index at 16 */ && 
11779                                       (MATCH_w_8_16 >> 3 & 0x7) 
11780                                             /* index at 16 */ < 8)) 
11781                                       goto MATCH_label_c1164;  /*opt-block+*/
11782                                     else 
11783                                       goto MATCH_label_c1163;  /*opt-block+*/
11784                                     
11785                                     break;
11786                                   case 5: 
11787                                     goto MATCH_label_c1165; break;
11788                                   default: assert(0);
11789                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
11790                               break;
11791                             case 1: 
11792                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11793                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11794                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11795                                       /* index at 16 */ && 
11796                                 (MATCH_w_8_16 >> 3 & 0x7) 
11797                                       /* index at 16 */ < 8)) { 
11798                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
11799                                 nextPC = 4 + MATCH_p; 
11800                                 
11801 #line 1796 "frontend/machine/pentium/decoder.m"
11802                                 
11803 
11804                                         stmts = instantiate(pc,  "FCOM.R64", DIS_MEM64);
11805 
11806                                 
11807 
11808                                 
11809                                 
11810                                 
11811                               } /*opt-block*//*opt-block+*/
11812                               else 
11813                                 goto MATCH_label_c1163;  /*opt-block+*/
11814                               
11815                               break;
11816                             case 2: 
11817                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11818                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11819                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11820                                       /* index at 16 */ && 
11821                                 (MATCH_w_8_16 >> 3 & 0x7) 
11822                                       /* index at 16 */ < 8)) 
11823                                 goto MATCH_label_c1164;  /*opt-block+*/
11824                               else 
11825                                 goto MATCH_label_c1165;  /*opt-block+*/
11826                               
11827                               break;
11828                             case 3: 
11829                               goto MATCH_label_c64; break;
11830                             default: assert(0);
11831                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
11832                         break;
11833                       case 3: 
11834                         
11835                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
11836                             case 0: 
11837                               
11838                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
11839                                   case 0: case 1: case 2: case 3: case 6: 
11840                                   case 7: 
11841                                     { 
11842                                       unsigned Mem64 = 
11843                                         1 + addressToPC(MATCH_p);
11844                                       nextPC = 2 + MATCH_p; 
11845                                       
11846 #line 1808 "frontend/machine/pentium/decoder.m"
11847                                       
11848 
11849                                             stmts = instantiate(pc,  "FCOMP.R64", DIS_MEM64);
11850 
11851                                       
11852 
11853                                       
11854                                       
11855                                       
11856                                     }
11857                                     
11858                                     break;
11859                                   case 4: 
11860                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
11861                                     if ((MATCH_w_8_16 & 0x7) 
11862                                             /* base at 16 */ == 5 && 
11863                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11864                                             /* index at 16 */ && 
11865                                       (MATCH_w_8_16 >> 3 & 0x7) 
11866                                             /* index at 16 */ < 8)) 
11867                                       goto MATCH_label_c1167;  /*opt-block+*/
11868                                     else 
11869                                       goto MATCH_label_c1166;  /*opt-block+*/
11870                                     
11871                                     break;
11872                                   case 5: 
11873                                     goto MATCH_label_c1168; break;
11874                                   default: assert(0);
11875                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
11876                               break;
11877                             case 1: 
11878                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11879                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11880                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11881                                       /* index at 16 */ && 
11882                                 (MATCH_w_8_16 >> 3 & 0x7) 
11883                                       /* index at 16 */ < 8)) { 
11884                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
11885                                 nextPC = 4 + MATCH_p; 
11886                                 
11887 #line 1808 "frontend/machine/pentium/decoder.m"
11888                                 
11889 
11890                                         stmts = instantiate(pc,  "FCOMP.R64", DIS_MEM64);
11891 
11892                                 
11893 
11894                                 
11895                                 
11896                                 
11897                               } /*opt-block*//*opt-block+*/
11898                               else 
11899                                 goto MATCH_label_c1166;  /*opt-block+*/
11900                               
11901                               break;
11902                             case 2: 
11903                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11904                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11905                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11906                                       /* index at 16 */ && 
11907                                 (MATCH_w_8_16 >> 3 & 0x7) 
11908                                       /* index at 16 */ < 8)) 
11909                                 goto MATCH_label_c1167;  /*opt-block+*/
11910                               else 
11911                                 goto MATCH_label_c1168;  /*opt-block+*/
11912                               
11913                               break;
11914                             case 3: 
11915                               goto MATCH_label_c64; break;
11916                             default: assert(0);
11917                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
11918                         break;
11919                       case 4: 
11920                         
11921                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
11922                             case 0: 
11923                               
11924                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
11925                                   case 0: case 1: case 2: case 3: case 6: 
11926                                   case 7: 
11927                                     { 
11928                                       unsigned Mem64 = 
11929                                         1 + addressToPC(MATCH_p);
11930                                       nextPC = 2 + MATCH_p; 
11931                                       
11932 #line 2047 "frontend/machine/pentium/decoder.m"
11933                                       
11934 
11935                                             stmts = instantiate(pc,  "FSUB.R64", DIS_MEM64);
11936 
11937                                       
11938 
11939                                       
11940                                       
11941                                       
11942                                     }
11943                                     
11944                                     break;
11945                                   case 4: 
11946                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
11947                                     if ((MATCH_w_8_16 & 0x7) 
11948                                             /* base at 16 */ == 5 && 
11949                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11950                                             /* index at 16 */ && 
11951                                       (MATCH_w_8_16 >> 3 & 0x7) 
11952                                             /* index at 16 */ < 8)) 
11953                                       goto MATCH_label_c1170;  /*opt-block+*/
11954                                     else 
11955                                       goto MATCH_label_c1169;  /*opt-block+*/
11956                                     
11957                                     break;
11958                                   case 5: 
11959                                     goto MATCH_label_c1171; break;
11960                                   default: assert(0);
11961                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
11962                               break;
11963                             case 1: 
11964                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11965                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11966                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11967                                       /* index at 16 */ && 
11968                                 (MATCH_w_8_16 >> 3 & 0x7) 
11969                                       /* index at 16 */ < 8)) { 
11970                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
11971                                 nextPC = 4 + MATCH_p; 
11972                                 
11973 #line 2047 "frontend/machine/pentium/decoder.m"
11974                                 
11975 
11976                                         stmts = instantiate(pc,  "FSUB.R64", DIS_MEM64);
11977 
11978                                 
11979 
11980                                 
11981                                 
11982                                 
11983                               } /*opt-block*//*opt-block+*/
11984                               else 
11985                                 goto MATCH_label_c1169;  /*opt-block+*/
11986                               
11987                               break;
11988                             case 2: 
11989                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
11990                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
11991                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
11992                                       /* index at 16 */ && 
11993                                 (MATCH_w_8_16 >> 3 & 0x7) 
11994                                       /* index at 16 */ < 8)) 
11995                                 goto MATCH_label_c1170;  /*opt-block+*/
11996                               else 
11997                                 goto MATCH_label_c1171;  /*opt-block+*/
11998                               
11999                               break;
12000                             case 3: 
12001                               { 
12002                                 unsigned idx = 
12003                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
12004                                 nextPC = 2 + MATCH_p; 
12005                                 
12006 #line 2074 "frontend/machine/pentium/decoder.m"
12007                                 
12008 
12009                                         stmts = instantiate(pc,  "FSUBR.STi.ST", DIS_IDX);
12010 
12011                                 
12012 
12013                                 
12014                                 
12015                                 
12016                               }
12017                               
12018                               break;
12019                             default: assert(0);
12020                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
12021                         break;
12022                       case 5: 
12023                         
12024                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
12025                             case 0: 
12026                               
12027                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
12028                                   case 0: case 1: case 2: case 3: case 6: 
12029                                   case 7: 
12030                                     { 
12031                                       unsigned Mem64 = 
12032                                         1 + addressToPC(MATCH_p);
12033                                       nextPC = 2 + MATCH_p; 
12034                                       
12035 #line 2068 "frontend/machine/pentium/decoder.m"
12036                                       
12037 
12038                                             stmts = instantiate(pc,  "FSUBR.R64", DIS_MEM64);
12039 
12040                                       
12041 
12042                                       
12043                                       
12044                                       
12045                                     }
12046                                     
12047                                     break;
12048                                   case 4: 
12049                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
12050                                     if ((MATCH_w_8_16 & 0x7) 
12051                                             /* base at 16 */ == 5 && 
12052                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12053                                             /* index at 16 */ && 
12054                                       (MATCH_w_8_16 >> 3 & 0x7) 
12055                                             /* index at 16 */ < 8)) 
12056                                       goto MATCH_label_c1173;  /*opt-block+*/
12057                                     else 
12058                                       goto MATCH_label_c1172;  /*opt-block+*/
12059                                     
12060                                     break;
12061                                   case 5: 
12062                                     goto MATCH_label_c1174; break;
12063                                   default: assert(0);
12064                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
12065                               break;
12066                             case 1: 
12067                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
12068                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
12069                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12070                                       /* index at 16 */ && 
12071                                 (MATCH_w_8_16 >> 3 & 0x7) 
12072                                       /* index at 16 */ < 8)) { 
12073                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
12074                                 nextPC = 4 + MATCH_p; 
12075                                 
12076 #line 2068 "frontend/machine/pentium/decoder.m"
12077                                 
12078 
12079                                         stmts = instantiate(pc,  "FSUBR.R64", DIS_MEM64);
12080 
12081                                 
12082 
12083                                 
12084                                 
12085                                 
12086                               } /*opt-block*//*opt-block+*/
12087                               else 
12088                                 goto MATCH_label_c1172;  /*opt-block+*/
12089                               
12090                               break;
12091                             case 2: 
12092                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
12093                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
12094                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12095                                       /* index at 16 */ && 
12096                                 (MATCH_w_8_16 >> 3 & 0x7) 
12097                                       /* index at 16 */ < 8)) 
12098                                 goto MATCH_label_c1173;  /*opt-block+*/
12099                               else 
12100                                 goto MATCH_label_c1174;  /*opt-block+*/
12101                               
12102                               break;
12103                             case 3: 
12104                               { 
12105                                 unsigned idx = 
12106                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
12107                                 nextPC = 2 + MATCH_p; 
12108                                 
12109 #line 2053 "frontend/machine/pentium/decoder.m"
12110                                 
12111 
12112                                         stmts = instantiate(pc,  "FSUB.STi.ST", DIS_IDX);
12113 
12114                                 
12115 
12116                                 
12117                                 
12118                                 
12119                               }
12120                               
12121                               break;
12122                             default: assert(0);
12123                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
12124                         break;
12125                       case 6: 
12126                         
12127                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
12128                             case 0: 
12129                               
12130                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
12131                                   case 0: case 1: case 2: case 3: case 6: 
12132                                   case 7: 
12133                                     { 
12134                                       unsigned Mem64 = 
12135                                         1 + addressToPC(MATCH_p);
12136                                       nextPC = 2 + MATCH_p; 
12137                                       
12138 #line 1841 "frontend/machine/pentium/decoder.m"
12139                                       
12140 
12141                                             stmts = instantiate(pc,  "FDIV.R64", DIS_MEM64);
12142 
12143                                       
12144 
12145                                       
12146                                       
12147                                       
12148                                     }
12149                                     
12150                                     break;
12151                                   case 4: 
12152                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
12153                                     if ((MATCH_w_8_16 & 0x7) 
12154                                             /* base at 16 */ == 5 && 
12155                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12156                                             /* index at 16 */ && 
12157                                       (MATCH_w_8_16 >> 3 & 0x7) 
12158                                             /* index at 16 */ < 8)) 
12159                                       goto MATCH_label_c1176;  /*opt-block+*/
12160                                     else 
12161                                       goto MATCH_label_c1175;  /*opt-block+*/
12162                                     
12163                                     break;
12164                                   case 5: 
12165                                     goto MATCH_label_c1177; break;
12166                                   default: assert(0);
12167                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
12168                               break;
12169                             case 1: 
12170                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
12171                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
12172                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12173                                       /* index at 16 */ && 
12174                                 (MATCH_w_8_16 >> 3 & 0x7) 
12175                                       /* index at 16 */ < 8)) { 
12176                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
12177                                 nextPC = 4 + MATCH_p; 
12178                                 
12179 #line 1841 "frontend/machine/pentium/decoder.m"
12180                                 
12181 
12182                                         stmts = instantiate(pc,  "FDIV.R64", DIS_MEM64);
12183 
12184                                 
12185 
12186                                 
12187                                 
12188                                 
12189                               } /*opt-block*//*opt-block+*/
12190                               else 
12191                                 goto MATCH_label_c1175;  /*opt-block+*/
12192                               
12193                               break;
12194                             case 2: 
12195                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
12196                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
12197                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12198                                       /* index at 16 */ && 
12199                                 (MATCH_w_8_16 >> 3 & 0x7) 
12200                                       /* index at 16 */ < 8)) 
12201                                 goto MATCH_label_c1176;  /*opt-block+*/
12202                               else 
12203                                 goto MATCH_label_c1177;  /*opt-block+*/
12204                               
12205                               break;
12206                             case 3: 
12207                               { 
12208                                 unsigned idx = 
12209                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
12210                                 nextPC = 2 + MATCH_p; 
12211                                 
12212 #line 1868 "frontend/machine/pentium/decoder.m"
12213                                 
12214 
12215                                         stmts = instantiate(pc,  "FDIVR.STi.ST", DIS_IDX);
12216 
12217                                 
12218 
12219                                 
12220                                 
12221                                 
12222                               }
12223                               
12224                               break;
12225                             default: assert(0);
12226                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
12227                         break;
12228                       case 7: 
12229                         
12230                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
12231                             case 0: 
12232                               
12233                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
12234                                   case 0: case 1: case 2: case 3: case 6: 
12235                                   case 7: 
12236                                     { 
12237                                       unsigned Mem64 = 
12238                                         1 + addressToPC(MATCH_p);
12239                                       nextPC = 2 + MATCH_p; 
12240                                       
12241 #line 1862 "frontend/machine/pentium/decoder.m"
12242                                       
12243 
12244                                             stmts = instantiate(pc,  "FDIVR.R64", DIS_MEM64);
12245 
12246                                       
12247 
12248                                       
12249                                       
12250                                       
12251                                     }
12252                                     
12253                                     break;
12254                                   case 4: 
12255                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
12256                                     if ((MATCH_w_8_16 & 0x7) 
12257                                             /* base at 16 */ == 5 && 
12258                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12259                                             /* index at 16 */ && 
12260                                       (MATCH_w_8_16 >> 3 & 0x7) 
12261                                             /* index at 16 */ < 8)) 
12262                                       goto MATCH_label_c1179;  /*opt-block+*/
12263                                     else 
12264                                       goto MATCH_label_c1178;  /*opt-block+*/
12265                                     
12266                                     break;
12267                                   case 5: 
12268                                     goto MATCH_label_c1180; break;
12269                                   default: assert(0);
12270                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
12271                               break;
12272                             case 1: 
12273                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
12274                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
12275                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12276                                       /* index at 16 */ && 
12277                                 (MATCH_w_8_16 >> 3 & 0x7) 
12278                                       /* index at 16 */ < 8)) { 
12279                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
12280                                 nextPC = 4 + MATCH_p; 
12281                                 
12282 #line 1862 "frontend/machine/pentium/decoder.m"
12283                                 
12284 
12285                                         stmts = instantiate(pc,  "FDIVR.R64", DIS_MEM64);
12286 
12287                                 
12288 
12289                                 
12290                                 
12291                                 
12292                               } /*opt-block*//*opt-block+*/
12293                               else 
12294                                 goto MATCH_label_c1178;  /*opt-block+*/
12295                               
12296                               break;
12297                             case 2: 
12298                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
12299                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
12300                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12301                                       /* index at 16 */ && 
12302                                 (MATCH_w_8_16 >> 3 & 0x7) 
12303                                       /* index at 16 */ < 8)) 
12304                                 goto MATCH_label_c1179;  /*opt-block+*/
12305                               else 
12306                                 goto MATCH_label_c1180;  /*opt-block+*/
12307                               
12308                               break;
12309                             case 3: 
12310                               { 
12311                                 unsigned idx = 
12312                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
12313                                 nextPC = 2 + MATCH_p; 
12314                                 
12315 #line 1847 "frontend/machine/pentium/decoder.m"
12316                                 
12317 
12318                                         stmts = instantiate(pc,  "FDIV.STi.ST", DIS_IDX);
12319 
12320                                 
12321 
12322                                 
12323                                 
12324                                 
12325                               }
12326                               
12327                               break;
12328                             default: assert(0);
12329                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
12330                         break;
12331                       default: assert(0);
12332                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
12333                   
12334                   break;
12335                 case 5: 
12336                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
12337                   
12338                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
12339                       case 0: 
12340                         
12341                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
12342                             case 0: 
12343                               
12344                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
12345                                   case 0: case 1: case 2: case 3: case 6: 
12346                                   case 7: 
12347                                     { 
12348                                       unsigned Mem64 = 
12349                                         1 + addressToPC(MATCH_p);
12350                                       nextPC = 2 + MATCH_p; 
12351                                       
12352 #line 1913 "frontend/machine/pentium/decoder.m"
12353                                       
12354 
12355                                             stmts = instantiate(pc,  "FLD.lsR64", DIS_MEM64);
12356 
12357                                       
12358 
12359                                       
12360                                       
12361                                       
12362                                     }
12363                                     
12364                                     break;
12365                                   case 4: 
12366                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
12367                                     if ((MATCH_w_8_16 & 0x7) 
12368                                             /* base at 16 */ == 5 && 
12369                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12370                                             /* index at 16 */ && 
12371                                       (MATCH_w_8_16 >> 3 & 0x7) 
12372                                             /* index at 16 */ < 8)) 
12373                                       goto MATCH_label_c1182;  /*opt-block+*/
12374                                     else 
12375                                       goto MATCH_label_c1181;  /*opt-block+*/
12376                                     
12377                                     break;
12378                                   case 5: 
12379                                     goto MATCH_label_c1183; break;
12380                                   default: assert(0);
12381                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
12382                               break;
12383                             case 1: 
12384                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
12385                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
12386                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12387                                       /* index at 16 */ && 
12388                                 (MATCH_w_8_16 >> 3 & 0x7) 
12389                                       /* index at 16 */ < 8)) { 
12390                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
12391                                 nextPC = 4 + MATCH_p; 
12392                                 
12393 #line 1913 "frontend/machine/pentium/decoder.m"
12394                                 
12395 
12396                                         stmts = instantiate(pc,  "FLD.lsR64", DIS_MEM64);
12397 
12398                                 
12399 
12400                                 
12401                                 
12402                                 
12403                               } /*opt-block*//*opt-block+*/
12404                               else 
12405                                 goto MATCH_label_c1181;  /*opt-block+*/
12406                               
12407                               break;
12408                             case 2: 
12409                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
12410                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
12411                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12412                                       /* index at 16 */ && 
12413                                 (MATCH_w_8_16 >> 3 & 0x7) 
12414                                       /* index at 16 */ < 8)) 
12415                                 goto MATCH_label_c1182;  /*opt-block+*/
12416                               else 
12417                                 goto MATCH_label_c1183;  /*opt-block+*/
12418                               
12419                               break;
12420                             case 3: 
12421                               { 
12422                                 unsigned idx = 
12423                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
12424                                 nextPC = 2 + MATCH_p; 
12425                                 
12426 #line 1880 "frontend/machine/pentium/decoder.m"
12427                                 
12428 
12429                                         stmts = instantiate(pc,  "FFREE", DIS_IDX);
12430 
12431                                 
12432 
12433                                 
12434                                 
12435                                 
12436                               }
12437                               
12438                               break;
12439                             default: assert(0);
12440                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
12441                         break;
12442                       case 1: 
12443                         goto MATCH_label_c64; break;
12444                       case 2: 
12445                         
12446                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
12447                             case 0: 
12448                               
12449                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
12450                                   case 0: case 1: case 2: case 3: case 6: 
12451                                   case 7: 
12452                                     { 
12453                                       unsigned Mem64 = 
12454                                         1 + addressToPC(MATCH_p);
12455                                       nextPC = 2 + MATCH_p; 
12456                                       
12457 #line 2014 "frontend/machine/pentium/decoder.m"
12458                                       
12459 
12460                                             stmts = instantiate(pc,  "FST.lsR64", DIS_MEM64);
12461 
12462                                       
12463 
12464                                       
12465                                       
12466                                       
12467                                     }
12468                                     
12469                                     break;
12470                                   case 4: 
12471                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
12472                                     if ((MATCH_w_8_16 & 0x7) 
12473                                             /* base at 16 */ == 5 && 
12474                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12475                                             /* index at 16 */ && 
12476                                       (MATCH_w_8_16 >> 3 & 0x7) 
12477                                             /* index at 16 */ < 8)) 
12478                                       goto MATCH_label_c1185;  /*opt-block+*/
12479                                     else 
12480                                       goto MATCH_label_c1184;  /*opt-block+*/
12481                                     
12482                                     break;
12483                                   case 5: 
12484                                     goto MATCH_label_c1186; break;
12485                                   default: assert(0);
12486                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
12487                               break;
12488                             case 1: 
12489                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
12490                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
12491                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12492                                       /* index at 16 */ && 
12493                                 (MATCH_w_8_16 >> 3 & 0x7) 
12494                                       /* index at 16 */ < 8)) { 
12495                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
12496                                 nextPC = 4 + MATCH_p; 
12497                                 
12498 #line 2014 "frontend/machine/pentium/decoder.m"
12499                                 
12500 
12501                                         stmts = instantiate(pc,  "FST.lsR64", DIS_MEM64);
12502 
12503                                 
12504 
12505                                 
12506                                 
12507                                 
12508                               } /*opt-block*//*opt-block+*/
12509                               else 
12510                                 goto MATCH_label_c1184;  /*opt-block+*/
12511                               
12512                               break;
12513                             case 2: 
12514                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
12515                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
12516                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12517                                       /* index at 16 */ && 
12518                                 (MATCH_w_8_16 >> 3 & 0x7) 
12519                                       /* index at 16 */ < 8)) 
12520                                 goto MATCH_label_c1185;  /*opt-block+*/
12521                               else 
12522                                 goto MATCH_label_c1186;  /*opt-block+*/
12523                               
12524                               break;
12525                             case 3: 
12526                               { 
12527                                 unsigned idx = 
12528                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
12529                                 nextPC = 2 + MATCH_p; 
12530                                 
12531 #line 2026 "frontend/machine/pentium/decoder.m"
12532                                 
12533 
12534                                         stmts = instantiate(pc,  "FST.st.STi", DIS_IDX);
12535 
12536                                 
12537 
12538                                 
12539                                 
12540                                 
12541                               }
12542                               
12543                               break;
12544                             default: assert(0);
12545                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
12546                         break;
12547                       case 3: 
12548                         
12549                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
12550                             case 0: 
12551                               
12552                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
12553                                   case 0: case 1: case 2: case 3: case 6: 
12554                                   case 7: 
12555                                     { 
12556                                       unsigned Mem64 = 
12557                                         1 + addressToPC(MATCH_p);
12558                                       nextPC = 2 + MATCH_p; 
12559                                       
12560 #line 2020 "frontend/machine/pentium/decoder.m"
12561                                       
12562 
12563                                             stmts = instantiate(pc,  "FSTP.lsR64", DIS_MEM64);
12564 
12565                                       
12566 
12567                                       
12568                                       
12569                                       
12570                                     }
12571                                     
12572                                     break;
12573                                   case 4: 
12574                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
12575                                     if ((MATCH_w_8_16 & 0x7) 
12576                                             /* base at 16 */ == 5 && 
12577                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12578                                             /* index at 16 */ && 
12579                                       (MATCH_w_8_16 >> 3 & 0x7) 
12580                                             /* index at 16 */ < 8)) 
12581                                       goto MATCH_label_c1188;  /*opt-block+*/
12582                                     else 
12583                                       goto MATCH_label_c1187;  /*opt-block+*/
12584                                     
12585                                     break;
12586                                   case 5: 
12587                                     goto MATCH_label_c1189; break;
12588                                   default: assert(0);
12589                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
12590                               break;
12591                             case 1: 
12592                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
12593                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
12594                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12595                                       /* index at 16 */ && 
12596                                 (MATCH_w_8_16 >> 3 & 0x7) 
12597                                       /* index at 16 */ < 8)) { 
12598                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
12599                                 nextPC = 4 + MATCH_p; 
12600                                 
12601 #line 2020 "frontend/machine/pentium/decoder.m"
12602                                 
12603 
12604                                         stmts = instantiate(pc,  "FSTP.lsR64", DIS_MEM64);
12605 
12606                                 
12607 
12608                                 
12609                                 
12610                                 
12611                               } /*opt-block*//*opt-block+*/
12612                               else 
12613                                 goto MATCH_label_c1187;  /*opt-block+*/
12614                               
12615                               break;
12616                             case 2: 
12617                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
12618                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
12619                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12620                                       /* index at 16 */ && 
12621                                 (MATCH_w_8_16 >> 3 & 0x7) 
12622                                       /* index at 16 */ < 8)) 
12623                                 goto MATCH_label_c1188;  /*opt-block+*/
12624                               else 
12625                                 goto MATCH_label_c1189;  /*opt-block+*/
12626                               
12627                               break;
12628                             case 3: 
12629                               { 
12630                                 unsigned idx = 
12631                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
12632                                 nextPC = 2 + MATCH_p; 
12633                                 
12634 #line 2029 "frontend/machine/pentium/decoder.m"
12635                                 
12636 
12637                                         stmts = instantiate(pc,  "FSTP.st.STi", DIS_IDX);
12638 
12639                                 
12640 
12641                                 
12642                                 
12643                                 
12644                               }
12645                               
12646                               break;
12647                             default: assert(0);
12648                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
12649                         break;
12650                       case 4: 
12651                         
12652                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
12653                             case 0: 
12654                               
12655                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
12656                                   case 0: case 1: case 2: case 3: case 6: 
12657                                   case 7: 
12658                                     { 
12659                                       unsigned Mem = 1 + addressToPC(MATCH_p);
12660                                       nextPC = 2 + MATCH_p; 
12661                                       
12662 #line 1993 "frontend/machine/pentium/decoder.m"
12663                                       
12664 
12665                                             stmts = instantiate(pc,  "FRSTOR", DIS_MEM);
12666 
12667                                       
12668 
12669                                       
12670                                       
12671                                       
12672                                     }
12673                                     
12674                                     break;
12675                                   case 4: 
12676                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
12677                                     if ((MATCH_w_8_16 & 0x7) 
12678                                             /* base at 16 */ == 5 && 
12679                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12680                                             /* index at 16 */ && 
12681                                       (MATCH_w_8_16 >> 3 & 0x7) 
12682                                             /* index at 16 */ < 8)) 
12683                                       goto MATCH_label_c1191;  /*opt-block+*/
12684                                     else 
12685                                       goto MATCH_label_c1190;  /*opt-block+*/
12686                                     
12687                                     break;
12688                                   case 5: 
12689                                     goto MATCH_label_c1192; break;
12690                                   default: assert(0);
12691                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
12692                               break;
12693                             case 1: 
12694                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
12695                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
12696                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12697                                       /* index at 16 */ && 
12698                                 (MATCH_w_8_16 >> 3 & 0x7) 
12699                                       /* index at 16 */ < 8)) { 
12700                                 unsigned Mem = 1 + addressToPC(MATCH_p);
12701                                 nextPC = 4 + MATCH_p; 
12702                                 
12703 #line 1993 "frontend/machine/pentium/decoder.m"
12704                                 
12705 
12706                                         stmts = instantiate(pc,  "FRSTOR", DIS_MEM);
12707 
12708                                 
12709 
12710                                 
12711                                 
12712                                 
12713                               } /*opt-block*//*opt-block+*/
12714                               else 
12715                                 goto MATCH_label_c1190;  /*opt-block+*/
12716                               
12717                               break;
12718                             case 2: 
12719                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
12720                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
12721                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12722                                       /* index at 16 */ && 
12723                                 (MATCH_w_8_16 >> 3 & 0x7) 
12724                                       /* index at 16 */ < 8)) 
12725                                 goto MATCH_label_c1191;  /*opt-block+*/
12726                               else 
12727                                 goto MATCH_label_c1192;  /*opt-block+*/
12728                               
12729                               break;
12730                             case 3: 
12731                               { 
12732                                 unsigned idx = 
12733                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
12734                                 nextPC = 2 + MATCH_p; 
12735                                 
12736 #line 2089 "frontend/machine/pentium/decoder.m"
12737                                 
12738 
12739                                         stmts = instantiate(pc,  "FUCOM", DIS_IDX);
12740 
12741                                 
12742 
12743                                 
12744                                 
12745                                 
12746                               }
12747                               
12748                               break;
12749                             default: assert(0);
12750                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
12751                         break;
12752                       case 5: 
12753                         if ((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */ == 3) { 
12754                           unsigned idx = (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
12755                           nextPC = 2 + MATCH_p; 
12756                           
12757 #line 2092 "frontend/machine/pentium/decoder.m"
12758                           
12759 
12760                                 stmts = instantiate(pc,  "FUCOMP", DIS_IDX);
12761 
12762                           
12763 
12764                           
12765                           
12766                           
12767                         } /*opt-block*//*opt-block+*/
12768                         else 
12769                           goto MATCH_label_c64;  /*opt-block+*/
12770                         
12771                         break;
12772                       case 6: 
12773                         
12774                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
12775                             case 0: 
12776                               
12777                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
12778                                   case 0: case 1: case 2: case 3: case 6: 
12779                                   case 7: 
12780                                     { 
12781                                       unsigned Mem = 1 + addressToPC(MATCH_p);
12782                                       nextPC = 2 + MATCH_p; 
12783                                       
12784 #line 1996 "frontend/machine/pentium/decoder.m"
12785                                       
12786 
12787                                             stmts = instantiate(pc,  "FNSAVE", DIS_MEM);
12788 
12789                                       
12790 
12791                                       
12792                                       
12793                                       
12794                                     }
12795                                     
12796                                     break;
12797                                   case 4: 
12798                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
12799                                     if ((MATCH_w_8_16 & 0x7) 
12800                                             /* base at 16 */ == 5 && 
12801                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12802                                             /* index at 16 */ && 
12803                                       (MATCH_w_8_16 >> 3 & 0x7) 
12804                                             /* index at 16 */ < 8)) 
12805                                       goto MATCH_label_c1194;  /*opt-block+*/
12806                                     else 
12807                                       goto MATCH_label_c1193;  /*opt-block+*/
12808                                     
12809                                     break;
12810                                   case 5: 
12811                                     goto MATCH_label_c1195; break;
12812                                   default: assert(0);
12813                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
12814                               break;
12815                             case 1: 
12816                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
12817                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
12818                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12819                                       /* index at 16 */ && 
12820                                 (MATCH_w_8_16 >> 3 & 0x7) 
12821                                       /* index at 16 */ < 8)) { 
12822                                 unsigned Mem = 1 + addressToPC(MATCH_p);
12823                                 nextPC = 4 + MATCH_p; 
12824                                 
12825 #line 1996 "frontend/machine/pentium/decoder.m"
12826                                 
12827 
12828                                         stmts = instantiate(pc,  "FNSAVE", DIS_MEM);
12829 
12830                                 
12831 
12832                                 
12833                                 
12834                                 
12835                               } /*opt-block*//*opt-block+*/
12836                               else 
12837                                 goto MATCH_label_c1193;  /*opt-block+*/
12838                               
12839                               break;
12840                             case 2: 
12841                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
12842                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
12843                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12844                                       /* index at 16 */ && 
12845                                 (MATCH_w_8_16 >> 3 & 0x7) 
12846                                       /* index at 16 */ < 8)) 
12847                                 goto MATCH_label_c1194;  /*opt-block+*/
12848                               else 
12849                                 goto MATCH_label_c1195;  /*opt-block+*/
12850                               
12851                               break;
12852                             case 3: 
12853                               goto MATCH_label_c64; break;
12854                             default: assert(0);
12855                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
12856                         break;
12857                       case 7: 
12858                         
12859                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
12860                             case 0: 
12861                               
12862                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
12863                                   case 0: case 1: case 2: case 3: case 6: 
12864                                   case 7: 
12865                                     { 
12866                                       unsigned Mem16 = 
12867                                         1 + addressToPC(MATCH_p);
12868                                       nextPC = 2 + MATCH_p; 
12869                                       
12870 #line 2038 "frontend/machine/pentium/decoder.m"
12871                                       
12872 
12873                                             stmts = instantiate(pc,  "FSTSW", DIS_MEM16);
12874 
12875                                       
12876 
12877                                       
12878                                       
12879                                       
12880                                     }
12881                                     
12882                                     break;
12883                                   case 4: 
12884                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
12885                                     if ((MATCH_w_8_16 & 0x7) 
12886                                             /* base at 16 */ == 5 && 
12887                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12888                                             /* index at 16 */ && 
12889                                       (MATCH_w_8_16 >> 3 & 0x7) 
12890                                             /* index at 16 */ < 8)) 
12891                                       goto MATCH_label_c1197;  /*opt-block+*/
12892                                     else 
12893                                       goto MATCH_label_c1196;  /*opt-block+*/
12894                                     
12895                                     break;
12896                                   case 5: 
12897                                     goto MATCH_label_c1198; break;
12898                                   default: assert(0);
12899                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
12900                               break;
12901                             case 1: 
12902                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
12903                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
12904                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12905                                       /* index at 16 */ && 
12906                                 (MATCH_w_8_16 >> 3 & 0x7) 
12907                                       /* index at 16 */ < 8)) { 
12908                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
12909                                 nextPC = 4 + MATCH_p; 
12910                                 
12911 #line 2038 "frontend/machine/pentium/decoder.m"
12912                                 
12913 
12914                                         stmts = instantiate(pc,  "FSTSW", DIS_MEM16);
12915 
12916                                 
12917 
12918                                 
12919                                 
12920                                 
12921                               } /*opt-block*//*opt-block+*/
12922                               else 
12923                                 goto MATCH_label_c1196;  /*opt-block+*/
12924                               
12925                               break;
12926                             case 2: 
12927                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
12928                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
12929                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12930                                       /* index at 16 */ && 
12931                                 (MATCH_w_8_16 >> 3 & 0x7) 
12932                                       /* index at 16 */ < 8)) 
12933                                 goto MATCH_label_c1197;  /*opt-block+*/
12934                               else 
12935                                 goto MATCH_label_c1198;  /*opt-block+*/
12936                               
12937                               break;
12938                             case 3: 
12939                               goto MATCH_label_c64; break;
12940                             default: assert(0);
12941                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
12942                         break;
12943                       default: assert(0);
12944                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
12945                   
12946                   break;
12947                 case 6: 
12948                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
12949                   
12950                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
12951                       case 0: 
12952                         
12953                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
12954                             case 0: 
12955                               
12956                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
12957                                   case 0: case 1: case 2: case 3: case 6: 
12958                                   case 7: 
12959                                     { 
12960                                       unsigned Mem16 = 
12961                                         1 + addressToPC(MATCH_p);
12962                                       nextPC = 2 + MATCH_p; 
12963                                       
12964 #line 1778 "frontend/machine/pentium/decoder.m"
12965                                       
12966 
12967                                             stmts = instantiate(pc,  "FIADD.I16", DIS_MEM16);
12968 
12969                                       
12970 
12971                                       
12972                                       
12973                                       
12974                                     }
12975                                     
12976                                     break;
12977                                   case 4: 
12978                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
12979                                     if ((MATCH_w_8_16 & 0x7) 
12980                                             /* base at 16 */ == 5 && 
12981                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12982                                             /* index at 16 */ && 
12983                                       (MATCH_w_8_16 >> 3 & 0x7) 
12984                                             /* index at 16 */ < 8)) 
12985                                       goto MATCH_label_c1200;  /*opt-block+*/
12986                                     else 
12987                                       goto MATCH_label_c1199;  /*opt-block+*/
12988                                     
12989                                     break;
12990                                   case 5: 
12991                                     goto MATCH_label_c1201; break;
12992                                   default: assert(0);
12993                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
12994                               break;
12995                             case 1: 
12996                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
12997                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
12998                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
12999                                       /* index at 16 */ && 
13000                                 (MATCH_w_8_16 >> 3 & 0x7) 
13001                                       /* index at 16 */ < 8)) { 
13002                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
13003                                 nextPC = 4 + MATCH_p; 
13004                                 
13005 #line 1778 "frontend/machine/pentium/decoder.m"
13006                                 
13007 
13008                                         stmts = instantiate(pc,  "FIADD.I16", DIS_MEM16);
13009 
13010                                 
13011 
13012                                 
13013                                 
13014                                 
13015                               } /*opt-block*//*opt-block+*/
13016                               else 
13017                                 goto MATCH_label_c1199;  /*opt-block+*/
13018                               
13019                               break;
13020                             case 2: 
13021                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13022                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13023                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13024                                       /* index at 16 */ && 
13025                                 (MATCH_w_8_16 >> 3 & 0x7) 
13026                                       /* index at 16 */ < 8)) 
13027                                 goto MATCH_label_c1200;  /*opt-block+*/
13028                               else 
13029                                 goto MATCH_label_c1201;  /*opt-block+*/
13030                               
13031                               break;
13032                             case 3: 
13033                               { 
13034                                 unsigned idx = 
13035                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
13036                                 nextPC = 2 + MATCH_p; 
13037                                 
13038 #line 1772 "frontend/machine/pentium/decoder.m"
13039                                 
13040 
13041                                         stmts = instantiate(pc,  "FADDP.STi.ST", DIS_IDX);
13042 
13043                                 
13044 
13045                                 
13046                                 
13047                                 
13048                               }
13049                               
13050                               break;
13051                             default: assert(0);
13052                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
13053                         break;
13054                       case 1: 
13055                         
13056                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
13057                             case 0: 
13058                               
13059                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
13060                                   case 0: case 1: case 2: case 3: case 6: 
13061                                   case 7: 
13062                                     { 
13063                                       unsigned Mem16 = 
13064                                         1 + addressToPC(MATCH_p);
13065                                       nextPC = 2 + MATCH_p; 
13066                                       
13067 #line 1972 "frontend/machine/pentium/decoder.m"
13068                                       
13069 
13070                                             stmts = instantiate(pc,  "FIMUL.I16", DIS_MEM16);
13071 
13072                                       
13073 
13074                                       
13075                                       
13076                                       
13077                                     }
13078                                     
13079                                     break;
13080                                   case 4: 
13081                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
13082                                     if ((MATCH_w_8_16 & 0x7) 
13083                                             /* base at 16 */ == 5 && 
13084                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13085                                             /* index at 16 */ && 
13086                                       (MATCH_w_8_16 >> 3 & 0x7) 
13087                                             /* index at 16 */ < 8)) 
13088                                       goto MATCH_label_c1203;  /*opt-block+*/
13089                                     else 
13090                                       goto MATCH_label_c1202;  /*opt-block+*/
13091                                     
13092                                     break;
13093                                   case 5: 
13094                                     goto MATCH_label_c1204; break;
13095                                   default: assert(0);
13096                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
13097                               break;
13098                             case 1: 
13099                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13100                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13101                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13102                                       /* index at 16 */ && 
13103                                 (MATCH_w_8_16 >> 3 & 0x7) 
13104                                       /* index at 16 */ < 8)) { 
13105                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
13106                                 nextPC = 4 + MATCH_p; 
13107                                 
13108 #line 1972 "frontend/machine/pentium/decoder.m"
13109                                 
13110 
13111                                         stmts = instantiate(pc,  "FIMUL.I16", DIS_MEM16);
13112 
13113                                 
13114 
13115                                 
13116                                 
13117                                 
13118                               } /*opt-block*//*opt-block+*/
13119                               else 
13120                                 goto MATCH_label_c1202;  /*opt-block+*/
13121                               
13122                               break;
13123                             case 2: 
13124                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13125                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13126                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13127                                       /* index at 16 */ && 
13128                                 (MATCH_w_8_16 >> 3 & 0x7) 
13129                                       /* index at 16 */ < 8)) 
13130                                 goto MATCH_label_c1203;  /*opt-block+*/
13131                               else 
13132                                 goto MATCH_label_c1204;  /*opt-block+*/
13133                               
13134                               break;
13135                             case 3: 
13136                               { 
13137                                 unsigned idx = 
13138                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
13139                                 nextPC = 2 + MATCH_p; 
13140                                 
13141 #line 1966 "frontend/machine/pentium/decoder.m"
13142                                 
13143 
13144                                         stmts = instantiate(pc,  "FMULP.STi.ST", DIS_IDX);
13145 
13146                                 
13147 
13148                                 
13149                                 
13150                                 
13151                               }
13152                               
13153                               break;
13154                             default: assert(0);
13155                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
13156                         break;
13157                       case 2: 
13158                         
13159                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
13160                             case 0: 
13161                               
13162                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
13163                                   case 0: case 1: case 2: case 3: case 6: 
13164                                   case 7: 
13165                                     { 
13166                                       unsigned Mem16 = 
13167                                         1 + addressToPC(MATCH_p);
13168                                       nextPC = 2 + MATCH_p; 
13169                                       
13170 #line 1802 "frontend/machine/pentium/decoder.m"
13171                                       
13172 
13173                                             stmts = instantiate(pc,  "FICOM.I16", DIS_MEM16);
13174 
13175                                       
13176 
13177                                       
13178                                       
13179                                       
13180                                     }
13181                                     
13182                                     break;
13183                                   case 4: 
13184                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
13185                                     if ((MATCH_w_8_16 & 0x7) 
13186                                             /* base at 16 */ == 5 && 
13187                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13188                                             /* index at 16 */ && 
13189                                       (MATCH_w_8_16 >> 3 & 0x7) 
13190                                             /* index at 16 */ < 8)) 
13191                                       goto MATCH_label_c1206;  /*opt-block+*/
13192                                     else 
13193                                       goto MATCH_label_c1205;  /*opt-block+*/
13194                                     
13195                                     break;
13196                                   case 5: 
13197                                     goto MATCH_label_c1207; break;
13198                                   default: assert(0);
13199                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
13200                               break;
13201                             case 1: 
13202                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13203                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13204                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13205                                       /* index at 16 */ && 
13206                                 (MATCH_w_8_16 >> 3 & 0x7) 
13207                                       /* index at 16 */ < 8)) { 
13208                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
13209                                 nextPC = 4 + MATCH_p; 
13210                                 
13211 #line 1802 "frontend/machine/pentium/decoder.m"
13212                                 
13213 
13214                                         stmts = instantiate(pc,  "FICOM.I16", DIS_MEM16);
13215 
13216                                 
13217 
13218                                 
13219                                 
13220                                 
13221                               } /*opt-block*//*opt-block+*/
13222                               else 
13223                                 goto MATCH_label_c1205;  /*opt-block+*/
13224                               
13225                               break;
13226                             case 2: 
13227                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13228                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13229                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13230                                       /* index at 16 */ && 
13231                                 (MATCH_w_8_16 >> 3 & 0x7) 
13232                                       /* index at 16 */ < 8)) 
13233                                 goto MATCH_label_c1206;  /*opt-block+*/
13234                               else 
13235                                 goto MATCH_label_c1207;  /*opt-block+*/
13236                               
13237                               break;
13238                             case 3: 
13239                               goto MATCH_label_c64; break;
13240                             default: assert(0);
13241                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
13242                         break;
13243                       case 3: 
13244                         
13245                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
13246                             case 0: 
13247                               
13248                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
13249                                   case 0: case 1: case 2: case 3: case 6: 
13250                                   case 7: 
13251                                     { 
13252                                       unsigned Mem16 = 
13253                                         1 + addressToPC(MATCH_p);
13254                                       nextPC = 2 + MATCH_p; 
13255                                       
13256 #line 1820 "frontend/machine/pentium/decoder.m"
13257                                       
13258 
13259                                             stmts = instantiate(pc,  "FICOMP.I16", DIS_MEM16);
13260 
13261                                       
13262 
13263                                       
13264                                       
13265                                       
13266                                     }
13267                                     
13268                                     break;
13269                                   case 4: 
13270                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
13271                                     if ((MATCH_w_8_16 & 0x7) 
13272                                             /* base at 16 */ == 5 && 
13273                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13274                                             /* index at 16 */ && 
13275                                       (MATCH_w_8_16 >> 3 & 0x7) 
13276                                             /* index at 16 */ < 8)) 
13277                                       goto MATCH_label_c1209;  /*opt-block+*/
13278                                     else 
13279                                       goto MATCH_label_c1208;  /*opt-block+*/
13280                                     
13281                                     break;
13282                                   case 5: 
13283                                     goto MATCH_label_c1210; break;
13284                                   default: assert(0);
13285                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
13286                               break;
13287                             case 1: 
13288                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13289                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13290                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13291                                       /* index at 16 */ && 
13292                                 (MATCH_w_8_16 >> 3 & 0x7) 
13293                                       /* index at 16 */ < 8)) { 
13294                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
13295                                 nextPC = 4 + MATCH_p; 
13296                                 
13297 #line 1820 "frontend/machine/pentium/decoder.m"
13298                                 
13299 
13300                                         stmts = instantiate(pc,  "FICOMP.I16", DIS_MEM16);
13301 
13302                                 
13303 
13304                                 
13305                                 
13306                                 
13307                               } /*opt-block*//*opt-block+*/
13308                               else 
13309                                 goto MATCH_label_c1208;  /*opt-block+*/
13310                               
13311                               break;
13312                             case 2: 
13313                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13314                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13315                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13316                                       /* index at 16 */ && 
13317                                 (MATCH_w_8_16 >> 3 & 0x7) 
13318                                       /* index at 16 */ < 8)) 
13319                                 goto MATCH_label_c1209;  /*opt-block+*/
13320                               else 
13321                                 goto MATCH_label_c1210;  /*opt-block+*/
13322                               
13323                               break;
13324                             case 3: 
13325                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 1) { 
13326                                 nextPC = 2 + MATCH_p; 
13327                                 
13328 #line 1823 "frontend/machine/pentium/decoder.m"
13329                                 
13330 
13331                                         stmts = instantiate(pc,  "FCOMPP");
13332 
13333                                 
13334 
13335                                 
13336                                 
13337                                 
13338                               } /*opt-block*//*opt-block+*/
13339                               else 
13340                                 goto MATCH_label_c64;  /*opt-block+*/
13341                               
13342                               break;
13343                             default: assert(0);
13344                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
13345                         break;
13346                       case 4: 
13347                         
13348                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
13349                             case 0: 
13350                               
13351                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
13352                                   case 0: case 1: case 2: case 3: case 6: 
13353                                   case 7: 
13354                                     { 
13355                                       unsigned Mem16 = 
13356                                         1 + addressToPC(MATCH_p);
13357                                       nextPC = 2 + MATCH_p; 
13358                                       
13359 #line 2059 "frontend/machine/pentium/decoder.m"
13360                                       
13361 
13362                                             stmts = instantiate(pc,  "FISUB.I16", DIS_MEM16);
13363 
13364                                       
13365 
13366                                       
13367                                       
13368                                       
13369                                     }
13370                                     
13371                                     break;
13372                                   case 4: 
13373                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
13374                                     if ((MATCH_w_8_16 & 0x7) 
13375                                             /* base at 16 */ == 5 && 
13376                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13377                                             /* index at 16 */ && 
13378                                       (MATCH_w_8_16 >> 3 & 0x7) 
13379                                             /* index at 16 */ < 8)) 
13380                                       goto MATCH_label_c1212;  /*opt-block+*/
13381                                     else 
13382                                       goto MATCH_label_c1211;  /*opt-block+*/
13383                                     
13384                                     break;
13385                                   case 5: 
13386                                     goto MATCH_label_c1213; break;
13387                                   default: assert(0);
13388                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
13389                               break;
13390                             case 1: 
13391                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13392                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13393                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13394                                       /* index at 16 */ && 
13395                                 (MATCH_w_8_16 >> 3 & 0x7) 
13396                                       /* index at 16 */ < 8)) { 
13397                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
13398                                 nextPC = 4 + MATCH_p; 
13399                                 
13400 #line 2059 "frontend/machine/pentium/decoder.m"
13401                                 
13402 
13403                                         stmts = instantiate(pc,  "FISUB.I16", DIS_MEM16);
13404 
13405                                 
13406 
13407                                 
13408                                 
13409                                 
13410                               } /*opt-block*//*opt-block+*/
13411                               else 
13412                                 goto MATCH_label_c1211;  /*opt-block+*/
13413                               
13414                               break;
13415                             case 2: 
13416                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13417                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13418                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13419                                       /* index at 16 */ && 
13420                                 (MATCH_w_8_16 >> 3 & 0x7) 
13421                                       /* index at 16 */ < 8)) 
13422                                 goto MATCH_label_c1212;  /*opt-block+*/
13423                               else 
13424                                 goto MATCH_label_c1213;  /*opt-block+*/
13425                               
13426                               break;
13427                             case 3: 
13428                               { 
13429                                 unsigned idx = 
13430                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
13431                                 nextPC = 2 + MATCH_p; 
13432                                 
13433 #line 2083 "frontend/machine/pentium/decoder.m"
13434                                 
13435 
13436                                         stmts = instantiate(pc,  "FSUBRP.STi.ST", DIS_IDX);
13437 
13438                                 
13439 
13440                                 
13441                                 
13442                                 
13443                               }
13444                               
13445                               break;
13446                             default: assert(0);
13447                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
13448                         break;
13449                       case 5: 
13450                         
13451                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
13452                             case 0: 
13453                               
13454                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
13455                                   case 0: case 1: case 2: case 3: case 6: 
13456                                   case 7: 
13457                                     { 
13458                                       unsigned Mem16 = 
13459                                         1 + addressToPC(MATCH_p);
13460                                       nextPC = 2 + MATCH_p; 
13461                                       
13462 #line 2080 "frontend/machine/pentium/decoder.m"
13463                                       
13464 
13465                                             stmts = instantiate(pc,  "FISUBR.I16", DIS_MEM16);
13466 
13467                                       
13468 
13469                                       
13470                                       
13471                                       
13472                                     }
13473                                     
13474                                     break;
13475                                   case 4: 
13476                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
13477                                     if ((MATCH_w_8_16 & 0x7) 
13478                                             /* base at 16 */ == 5 && 
13479                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13480                                             /* index at 16 */ && 
13481                                       (MATCH_w_8_16 >> 3 & 0x7) 
13482                                             /* index at 16 */ < 8)) 
13483                                       goto MATCH_label_c1215;  /*opt-block+*/
13484                                     else 
13485                                       goto MATCH_label_c1214;  /*opt-block+*/
13486                                     
13487                                     break;
13488                                   case 5: 
13489                                     goto MATCH_label_c1216; break;
13490                                   default: assert(0);
13491                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
13492                               break;
13493                             case 1: 
13494                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13495                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13496                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13497                                       /* index at 16 */ && 
13498                                 (MATCH_w_8_16 >> 3 & 0x7) 
13499                                       /* index at 16 */ < 8)) { 
13500                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
13501                                 nextPC = 4 + MATCH_p; 
13502                                 
13503 #line 2080 "frontend/machine/pentium/decoder.m"
13504                                 
13505 
13506                                         stmts = instantiate(pc,  "FISUBR.I16", DIS_MEM16);
13507 
13508                                 
13509 
13510                                 
13511                                 
13512                                 
13513                               } /*opt-block*//*opt-block+*/
13514                               else 
13515                                 goto MATCH_label_c1214;  /*opt-block+*/
13516                               
13517                               break;
13518                             case 2: 
13519                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13520                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13521                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13522                                       /* index at 16 */ && 
13523                                 (MATCH_w_8_16 >> 3 & 0x7) 
13524                                       /* index at 16 */ < 8)) 
13525                                 goto MATCH_label_c1215;  /*opt-block+*/
13526                               else 
13527                                 goto MATCH_label_c1216;  /*opt-block+*/
13528                               
13529                               break;
13530                             case 3: 
13531                               { 
13532                                 unsigned idx = 
13533                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
13534                                 nextPC = 2 + MATCH_p; 
13535                                 
13536 #line 2062 "frontend/machine/pentium/decoder.m"
13537                                 
13538 
13539                                         stmts = instantiate(pc,  "FSUBP.STi.ST", DIS_IDX);
13540 
13541                                 
13542 
13543                                 
13544                                 
13545                                 
13546                               }
13547                               
13548                               break;
13549                             default: assert(0);
13550                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
13551                         break;
13552                       case 6: 
13553                         
13554                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
13555                             case 0: 
13556                               
13557                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
13558                                   case 0: case 1: case 2: case 3: case 6: 
13559                                   case 7: 
13560                                     { 
13561                                       unsigned Mem16 = 
13562                                         1 + addressToPC(MATCH_p);
13563                                       nextPC = 2 + MATCH_p; 
13564                                       
13565 #line 1856 "frontend/machine/pentium/decoder.m"
13566                                       
13567 
13568                                             stmts = instantiate(pc,  "FIDIV.I16", DIS_MEM16);
13569 
13570                                       
13571 
13572                                       
13573                                       
13574                                       
13575                                     }
13576                                     
13577                                     break;
13578                                   case 4: 
13579                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
13580                                     if ((MATCH_w_8_16 & 0x7) 
13581                                             /* base at 16 */ == 5 && 
13582                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13583                                             /* index at 16 */ && 
13584                                       (MATCH_w_8_16 >> 3 & 0x7) 
13585                                             /* index at 16 */ < 8)) 
13586                                       goto MATCH_label_c1218;  /*opt-block+*/
13587                                     else 
13588                                       goto MATCH_label_c1217;  /*opt-block+*/
13589                                     
13590                                     break;
13591                                   case 5: 
13592                                     goto MATCH_label_c1219; break;
13593                                   default: assert(0);
13594                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
13595                               break;
13596                             case 1: 
13597                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13598                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13599                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13600                                       /* index at 16 */ && 
13601                                 (MATCH_w_8_16 >> 3 & 0x7) 
13602                                       /* index at 16 */ < 8)) { 
13603                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
13604                                 nextPC = 4 + MATCH_p; 
13605                                 
13606 #line 1856 "frontend/machine/pentium/decoder.m"
13607                                 
13608 
13609                                         stmts = instantiate(pc,  "FIDIV.I16", DIS_MEM16);
13610 
13611                                 
13612 
13613                                 
13614                                 
13615                                 
13616                               } /*opt-block*//*opt-block+*/
13617                               else 
13618                                 goto MATCH_label_c1217;  /*opt-block+*/
13619                               
13620                               break;
13621                             case 2: 
13622                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13623                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13624                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13625                                       /* index at 16 */ && 
13626                                 (MATCH_w_8_16 >> 3 & 0x7) 
13627                                       /* index at 16 */ < 8)) 
13628                                 goto MATCH_label_c1218;  /*opt-block+*/
13629                               else 
13630                                 goto MATCH_label_c1219;  /*opt-block+*/
13631                               
13632                               break;
13633                             case 3: 
13634                               { 
13635                                 unsigned idx = 
13636                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
13637                                 nextPC = 2 + MATCH_p; 
13638                                 
13639 #line 1877 "frontend/machine/pentium/decoder.m"
13640                                 
13641 
13642                                         stmts = instantiate(pc,  "FDIVRP.STi.ST", DIS_IDX);
13643 
13644                                 
13645 
13646                                 
13647                                 
13648                                 
13649                               }
13650                               
13651                               break;
13652                             default: assert(0);
13653                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
13654                         break;
13655                       case 7: 
13656                         
13657                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
13658                             case 0: 
13659                               
13660                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
13661                                   case 0: case 1: case 2: case 3: case 6: 
13662                                   case 7: 
13663                                     { 
13664                                       unsigned Mem16 = 
13665                                         1 + addressToPC(MATCH_p);
13666                                       nextPC = 2 + MATCH_p; 
13667                                       
13668 #line 1874 "frontend/machine/pentium/decoder.m"
13669                                       
13670 
13671                                             stmts = instantiate(pc,  "FIDIVR.I16", DIS_MEM16);
13672 
13673                                       
13674 
13675                                       
13676                                       
13677                                       
13678                                     }
13679                                     
13680                                     break;
13681                                   case 4: 
13682                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
13683                                     if ((MATCH_w_8_16 & 0x7) 
13684                                             /* base at 16 */ == 5 && 
13685                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13686                                             /* index at 16 */ && 
13687                                       (MATCH_w_8_16 >> 3 & 0x7) 
13688                                             /* index at 16 */ < 8)) 
13689                                       goto MATCH_label_c1221;  /*opt-block+*/
13690                                     else 
13691                                       goto MATCH_label_c1220;  /*opt-block+*/
13692                                     
13693                                     break;
13694                                   case 5: 
13695                                     goto MATCH_label_c1222; break;
13696                                   default: assert(0);
13697                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
13698                               break;
13699                             case 1: 
13700                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13701                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13702                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13703                                       /* index at 16 */ && 
13704                                 (MATCH_w_8_16 >> 3 & 0x7) 
13705                                       /* index at 16 */ < 8)) { 
13706                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
13707                                 nextPC = 4 + MATCH_p; 
13708                                 
13709 #line 1874 "frontend/machine/pentium/decoder.m"
13710                                 
13711 
13712                                         stmts = instantiate(pc,  "FIDIVR.I16", DIS_MEM16);
13713 
13714                                 
13715 
13716                                 
13717                                 
13718                                 
13719                               } /*opt-block*//*opt-block+*/
13720                               else 
13721                                 goto MATCH_label_c1220;  /*opt-block+*/
13722                               
13723                               break;
13724                             case 2: 
13725                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13726                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13727                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13728                                       /* index at 16 */ && 
13729                                 (MATCH_w_8_16 >> 3 & 0x7) 
13730                                       /* index at 16 */ < 8)) 
13731                                 goto MATCH_label_c1221;  /*opt-block+*/
13732                               else 
13733                                 goto MATCH_label_c1222;  /*opt-block+*/
13734                               
13735                               break;
13736                             case 3: 
13737                               { 
13738                                 unsigned idx = 
13739                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
13740                                 nextPC = 2 + MATCH_p; 
13741                                 
13742 #line 1850 "frontend/machine/pentium/decoder.m"
13743                                 
13744 
13745                                         stmts = instantiate(pc,  "FDIVP.STi.ST", DIS_IDX);
13746 
13747                                 
13748 
13749                                 
13750                                 
13751                                 
13752                               }
13753                               
13754                               break;
13755                             default: assert(0);
13756                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
13757                         break;
13758                       default: assert(0);
13759                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
13760                   
13761                   break;
13762                 case 7: 
13763                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
13764                   
13765                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
13766                       case 0: 
13767                         
13768                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
13769                             case 0: 
13770                               
13771                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
13772                                   case 0: case 1: case 2: case 3: case 6: 
13773                                   case 7: 
13774                                     { 
13775                                       unsigned Mem16 = 
13776                                         1 + addressToPC(MATCH_p);
13777                                       nextPC = 2 + MATCH_p; 
13778                                       
13779 #line 1883 "frontend/machine/pentium/decoder.m"
13780                                       
13781 
13782                                             stmts = instantiate(pc,  "FILD.lsI16", DIS_MEM16);
13783 
13784                                       
13785 
13786                                       
13787                                       
13788                                       
13789                                     }
13790                                     
13791                                     break;
13792                                   case 4: 
13793                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
13794                                     if ((MATCH_w_8_16 & 0x7) 
13795                                             /* base at 16 */ == 5 && 
13796                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13797                                             /* index at 16 */ && 
13798                                       (MATCH_w_8_16 >> 3 & 0x7) 
13799                                             /* index at 16 */ < 8)) 
13800                                       goto MATCH_label_c1224;  /*opt-block+*/
13801                                     else 
13802                                       goto MATCH_label_c1223;  /*opt-block+*/
13803                                     
13804                                     break;
13805                                   case 5: 
13806                                     goto MATCH_label_c1225; break;
13807                                   default: assert(0);
13808                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
13809                               break;
13810                             case 1: 
13811                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13812                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13813                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13814                                       /* index at 16 */ && 
13815                                 (MATCH_w_8_16 >> 3 & 0x7) 
13816                                       /* index at 16 */ < 8)) { 
13817                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
13818                                 nextPC = 4 + MATCH_p; 
13819                                 
13820 #line 1883 "frontend/machine/pentium/decoder.m"
13821                                 
13822 
13823                                         stmts = instantiate(pc,  "FILD.lsI16", DIS_MEM16);
13824 
13825                                 
13826 
13827                                 
13828                                 
13829                                 
13830                               } /*opt-block*//*opt-block+*/
13831                               else 
13832                                 goto MATCH_label_c1223;  /*opt-block+*/
13833                               
13834                               break;
13835                             case 2: 
13836                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13837                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13838                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13839                                       /* index at 16 */ && 
13840                                 (MATCH_w_8_16 >> 3 & 0x7) 
13841                                       /* index at 16 */ < 8)) 
13842                                 goto MATCH_label_c1224;  /*opt-block+*/
13843                               else 
13844                                 goto MATCH_label_c1225;  /*opt-block+*/
13845                               
13846                               break;
13847                             case 3: 
13848                               goto MATCH_label_c64; break;
13849                             default: assert(0);
13850                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
13851                         break;
13852                       case 1: 
13853                         goto MATCH_label_c64; break;
13854                       case 2: 
13855                         
13856                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
13857                             case 0: 
13858                               
13859                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
13860                                   case 0: case 1: case 2: case 3: case 6: 
13861                                   case 7: 
13862                                     { 
13863                                       unsigned Mem16 = 
13864                                         1 + addressToPC(MATCH_p);
13865                                       nextPC = 2 + MATCH_p; 
13866                                       
13867 #line 1895 "frontend/machine/pentium/decoder.m"
13868                                       
13869 
13870                                             stmts = instantiate(pc,  "FIST.lsI16", DIS_MEM16);
13871 
13872                                       
13873 
13874                                       
13875                                       
13876                                       
13877                                     }
13878                                     
13879                                     break;
13880                                   case 4: 
13881                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
13882                                     if ((MATCH_w_8_16 & 0x7) 
13883                                             /* base at 16 */ == 5 && 
13884                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13885                                             /* index at 16 */ && 
13886                                       (MATCH_w_8_16 >> 3 & 0x7) 
13887                                             /* index at 16 */ < 8)) 
13888                                       goto MATCH_label_c1227;  /*opt-block+*/
13889                                     else 
13890                                       goto MATCH_label_c1226;  /*opt-block+*/
13891                                     
13892                                     break;
13893                                   case 5: 
13894                                     goto MATCH_label_c1228; break;
13895                                   default: assert(0);
13896                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
13897                               break;
13898                             case 1: 
13899                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13900                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13901                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13902                                       /* index at 16 */ && 
13903                                 (MATCH_w_8_16 >> 3 & 0x7) 
13904                                       /* index at 16 */ < 8)) { 
13905                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
13906                                 nextPC = 4 + MATCH_p; 
13907                                 
13908 #line 1895 "frontend/machine/pentium/decoder.m"
13909                                 
13910 
13911                                         stmts = instantiate(pc,  "FIST.lsI16", DIS_MEM16);
13912 
13913                                 
13914 
13915                                 
13916                                 
13917                                 
13918                               } /*opt-block*//*opt-block+*/
13919                               else 
13920                                 goto MATCH_label_c1226;  /*opt-block+*/
13921                               
13922                               break;
13923                             case 2: 
13924                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13925                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13926                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13927                                       /* index at 16 */ && 
13928                                 (MATCH_w_8_16 >> 3 & 0x7) 
13929                                       /* index at 16 */ < 8)) 
13930                                 goto MATCH_label_c1227;  /*opt-block+*/
13931                               else 
13932                                 goto MATCH_label_c1228;  /*opt-block+*/
13933                               
13934                               break;
13935                             case 3: 
13936                               goto MATCH_label_c64; break;
13937                             default: assert(0);
13938                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
13939                         break;
13940                       case 3: 
13941                         
13942                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
13943                             case 0: 
13944                               
13945                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
13946                                   case 0: case 1: case 2: case 3: case 6: 
13947                                   case 7: 
13948                                     { 
13949                                       unsigned Mem16 = 
13950                                         1 + addressToPC(MATCH_p);
13951                                       nextPC = 2 + MATCH_p; 
13952                                       
13953 #line 1901 "frontend/machine/pentium/decoder.m"
13954                                       
13955 
13956                                             stmts = instantiate(pc,  "FISTP.lsI16", DIS_MEM16);
13957 
13958                                       
13959 
13960                                       
13961                                       
13962                                       
13963                                     }
13964                                     
13965                                     break;
13966                                   case 4: 
13967                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
13968                                     if ((MATCH_w_8_16 & 0x7) 
13969                                             /* base at 16 */ == 5 && 
13970                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13971                                             /* index at 16 */ && 
13972                                       (MATCH_w_8_16 >> 3 & 0x7) 
13973                                             /* index at 16 */ < 8)) 
13974                                       goto MATCH_label_c1230;  /*opt-block+*/
13975                                     else 
13976                                       goto MATCH_label_c1229;  /*opt-block+*/
13977                                     
13978                                     break;
13979                                   case 5: 
13980                                     goto MATCH_label_c1231; break;
13981                                   default: assert(0);
13982                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
13983                               break;
13984                             case 1: 
13985                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
13986                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
13987                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
13988                                       /* index at 16 */ && 
13989                                 (MATCH_w_8_16 >> 3 & 0x7) 
13990                                       /* index at 16 */ < 8)) { 
13991                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
13992                                 nextPC = 4 + MATCH_p; 
13993                                 
13994 #line 1901 "frontend/machine/pentium/decoder.m"
13995                                 
13996 
13997                                         stmts = instantiate(pc,  "FISTP.lsI16", DIS_MEM16);
13998 
13999                                 
14000 
14001                                 
14002                                 
14003                                 
14004                               } /*opt-block*//*opt-block+*/
14005                               else 
14006                                 goto MATCH_label_c1229;  /*opt-block+*/
14007                               
14008                               break;
14009                             case 2: 
14010                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
14011                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
14012                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14013                                       /* index at 16 */ && 
14014                                 (MATCH_w_8_16 >> 3 & 0x7) 
14015                                       /* index at 16 */ < 8)) 
14016                                 goto MATCH_label_c1230;  /*opt-block+*/
14017                               else 
14018                                 goto MATCH_label_c1231;  /*opt-block+*/
14019                               
14020                               break;
14021                             case 3: 
14022                               goto MATCH_label_c64; break;
14023                             default: assert(0);
14024                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
14025                         break;
14026                       case 4: 
14027                         
14028                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
14029                             case 0: 
14030                               
14031                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
14032                                   case 0: case 1: case 2: case 3: case 6: 
14033                                   case 7: 
14034                                     { 
14035                                       unsigned Mem80 = 
14036                                         1 + addressToPC(MATCH_p);
14037                                       nextPC = 2 + MATCH_p; 
14038                                       
14039 #line 1781 "frontend/machine/pentium/decoder.m"
14040                                       
14041 
14042                                             stmts = instantiate(pc,  "FBLD", DIS_MEM80);
14043 
14044                                       
14045 
14046                                       
14047                                       
14048                                       
14049                                     }
14050                                     
14051                                     break;
14052                                   case 4: 
14053                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
14054                                     if ((MATCH_w_8_16 & 0x7) 
14055                                             /* base at 16 */ == 5 && 
14056                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14057                                             /* index at 16 */ && 
14058                                       (MATCH_w_8_16 >> 3 & 0x7) 
14059                                             /* index at 16 */ < 8)) 
14060                                       goto MATCH_label_c1233;  /*opt-block+*/
14061                                     else 
14062                                       goto MATCH_label_c1232;  /*opt-block+*/
14063                                     
14064                                     break;
14065                                   case 5: 
14066                                     goto MATCH_label_c1234; break;
14067                                   default: assert(0);
14068                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
14069                               break;
14070                             case 1: 
14071                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
14072                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
14073                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14074                                       /* index at 16 */ && 
14075                                 (MATCH_w_8_16 >> 3 & 0x7) 
14076                                       /* index at 16 */ < 8)) { 
14077                                 unsigned Mem80 = 1 + addressToPC(MATCH_p);
14078                                 nextPC = 4 + MATCH_p; 
14079                                 
14080 #line 1781 "frontend/machine/pentium/decoder.m"
14081                                 
14082 
14083                                         stmts = instantiate(pc,  "FBLD", DIS_MEM80);
14084 
14085                                 
14086 
14087                                 
14088                                 
14089                                 
14090                               } /*opt-block*//*opt-block+*/
14091                               else 
14092                                 goto MATCH_label_c1232;  /*opt-block+*/
14093                               
14094                               break;
14095                             case 2: 
14096                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
14097                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
14098                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14099                                       /* index at 16 */ && 
14100                                 (MATCH_w_8_16 >> 3 & 0x7) 
14101                                       /* index at 16 */ < 8)) 
14102                                 goto MATCH_label_c1233;  /*opt-block+*/
14103                               else 
14104                                 goto MATCH_label_c1234;  /*opt-block+*/
14105                               
14106                               break;
14107                             case 3: 
14108                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 0) { 
14109                                 nextPC = 2 + MATCH_p; 
14110                                 
14111 #line 2041 "frontend/machine/pentium/decoder.m"
14112                                 
14113 
14114                                         stmts = instantiate(pc,  "FSTSW.AX");
14115 
14116                                 
14117 
14118                                 
14119                                 
14120                                 
14121                               } /*opt-block*//*opt-block+*/
14122                               else 
14123                                 goto MATCH_label_c64;  /*opt-block+*/
14124                               
14125                               break;
14126                             default: assert(0);
14127                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
14128                         break;
14129                       case 5: 
14130                         
14131                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
14132                             case 0: 
14133                               
14134                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
14135                                   case 0: case 1: case 2: case 3: case 6: 
14136                                   case 7: 
14137                                     { 
14138                                       unsigned Mem64 = 
14139                                         1 + addressToPC(MATCH_p);
14140                                       nextPC = 2 + MATCH_p; 
14141                                       
14142 #line 1889 "frontend/machine/pentium/decoder.m"
14143                                       
14144 
14145                                             stmts = instantiate(pc,  "FILD.lsI64", DIS_MEM64);
14146 
14147                                       
14148 
14149                                       
14150                                       
14151                                       
14152                                     }
14153                                     
14154                                     break;
14155                                   case 4: 
14156                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
14157                                     if ((MATCH_w_8_16 & 0x7) 
14158                                             /* base at 16 */ == 5 && 
14159                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14160                                             /* index at 16 */ && 
14161                                       (MATCH_w_8_16 >> 3 & 0x7) 
14162                                             /* index at 16 */ < 8)) 
14163                                       goto MATCH_label_c1236;  /*opt-block+*/
14164                                     else 
14165                                       goto MATCH_label_c1235;  /*opt-block+*/
14166                                     
14167                                     break;
14168                                   case 5: 
14169                                     goto MATCH_label_c1237; break;
14170                                   default: assert(0);
14171                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
14172                               break;
14173                             case 1: 
14174                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
14175                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
14176                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14177                                       /* index at 16 */ && 
14178                                 (MATCH_w_8_16 >> 3 & 0x7) 
14179                                       /* index at 16 */ < 8)) { 
14180                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
14181                                 nextPC = 4 + MATCH_p; 
14182                                 
14183 #line 1889 "frontend/machine/pentium/decoder.m"
14184                                 
14185 
14186                                         stmts = instantiate(pc,  "FILD.lsI64", DIS_MEM64);
14187 
14188                                 
14189 
14190                                 
14191                                 
14192                                 
14193                               } /*opt-block*//*opt-block+*/
14194                               else 
14195                                 goto MATCH_label_c1235;  /*opt-block+*/
14196                               
14197                               break;
14198                             case 2: 
14199                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
14200                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
14201                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14202                                       /* index at 16 */ && 
14203                                 (MATCH_w_8_16 >> 3 & 0x7) 
14204                                       /* index at 16 */ < 8)) 
14205                                 goto MATCH_label_c1236;  /*opt-block+*/
14206                               else 
14207                                 goto MATCH_label_c1237;  /*opt-block+*/
14208                               
14209                               break;
14210                             case 3: 
14211                               MATCH_name = "FUCOMIP.ST.STi"; 
14212                               { 
14213                                 char *name = MATCH_name;
14214                                 unsigned idx = 
14215                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
14216                                 nextPC = 2 + MATCH_p; 
14217                                 
14218 #line 2101 "frontend/machine/pentium/decoder.m"
14219                                 
14220 
14221                                         stmts = instantiate(pc, name, DIS_IDX);
14222 
14223                                 
14224 
14225                                 
14226                                 
14227                                 
14228                               }
14229                               
14230                               break;
14231                             default: assert(0);
14232                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
14233                         break;
14234                       case 6: 
14235                         
14236                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
14237                             case 0: 
14238                               
14239                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
14240                                   case 0: case 1: case 2: case 3: case 6: 
14241                                   case 7: 
14242                                     { 
14243                                       unsigned Mem80 = 
14244                                         1 + addressToPC(MATCH_p);
14245                                       nextPC = 2 + MATCH_p; 
14246                                       
14247 #line 1784 "frontend/machine/pentium/decoder.m"
14248                                       
14249 
14250                                             stmts = instantiate(pc,  "FBSTP", DIS_MEM80);
14251 
14252                                       
14253 
14254                                       
14255                                       
14256                                       
14257                                     }
14258                                     
14259                                     break;
14260                                   case 4: 
14261                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
14262                                     if ((MATCH_w_8_16 & 0x7) 
14263                                             /* base at 16 */ == 5 && 
14264                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14265                                             /* index at 16 */ && 
14266                                       (MATCH_w_8_16 >> 3 & 0x7) 
14267                                             /* index at 16 */ < 8)) 
14268                                       goto MATCH_label_c1239;  /*opt-block+*/
14269                                     else 
14270                                       goto MATCH_label_c1238;  /*opt-block+*/
14271                                     
14272                                     break;
14273                                   case 5: 
14274                                     goto MATCH_label_c1240; break;
14275                                   default: assert(0);
14276                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
14277                               break;
14278                             case 1: 
14279                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
14280                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
14281                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14282                                       /* index at 16 */ && 
14283                                 (MATCH_w_8_16 >> 3 & 0x7) 
14284                                       /* index at 16 */ < 8)) { 
14285                                 unsigned Mem80 = 1 + addressToPC(MATCH_p);
14286                                 nextPC = 4 + MATCH_p; 
14287                                 
14288 #line 1784 "frontend/machine/pentium/decoder.m"
14289                                 
14290 
14291                                         stmts = instantiate(pc,  "FBSTP", DIS_MEM80);
14292 
14293                                 
14294 
14295                                 
14296                                 
14297                                 
14298                               } /*opt-block*//*opt-block+*/
14299                               else 
14300                                 goto MATCH_label_c1238;  /*opt-block+*/
14301                               
14302                               break;
14303                             case 2: 
14304                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
14305                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
14306                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14307                                       /* index at 16 */ && 
14308                                 (MATCH_w_8_16 >> 3 & 0x7) 
14309                                       /* index at 16 */ < 8)) 
14310                                 goto MATCH_label_c1239;  /*opt-block+*/
14311                               else 
14312                                 goto MATCH_label_c1240;  /*opt-block+*/
14313                               
14314                               break;
14315                             case 3: 
14316                               MATCH_name = "FCOMIP.ST.STi"; 
14317                               { 
14318                                 char *name = MATCH_name;
14319                                 unsigned idx = 
14320                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
14321                                 nextPC = 2 + MATCH_p; 
14322                                 
14323 #line 1829 "frontend/machine/pentium/decoder.m"
14324                                 
14325 
14326                                         stmts = instantiate(pc, name, DIS_IDX);
14327 
14328                                 
14329 
14330                                 
14331                                 
14332                                 
14333                               }
14334                               
14335                               break;
14336                             default: assert(0);
14337                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
14338                         break;
14339                       case 7: 
14340                         
14341                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
14342                             case 0: 
14343                               
14344                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
14345                                   case 0: case 1: case 2: case 3: case 6: 
14346                                   case 7: 
14347                                     { 
14348                                       unsigned Mem64 = 
14349                                         1 + addressToPC(MATCH_p);
14350                                       nextPC = 2 + MATCH_p; 
14351                                       
14352 #line 1907 "frontend/machine/pentium/decoder.m"
14353                                       
14354 
14355                                             stmts = instantiate(pc,  "FISTP64", DIS_MEM64);
14356 
14357                                       
14358 
14359                                       
14360                                       
14361                                       
14362                                     }
14363                                     
14364                                     break;
14365                                   case 4: 
14366                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
14367                                     if ((MATCH_w_8_16 & 0x7) 
14368                                             /* base at 16 */ == 5 && 
14369                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14370                                             /* index at 16 */ && 
14371                                       (MATCH_w_8_16 >> 3 & 0x7) 
14372                                             /* index at 16 */ < 8)) 
14373                                       goto MATCH_label_c1242;  /*opt-block+*/
14374                                     else 
14375                                       goto MATCH_label_c1241;  /*opt-block+*/
14376                                     
14377                                     break;
14378                                   case 5: 
14379                                     goto MATCH_label_c1243; break;
14380                                   default: assert(0);
14381                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
14382                               break;
14383                             case 1: 
14384                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
14385                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
14386                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14387                                       /* index at 16 */ && 
14388                                 (MATCH_w_8_16 >> 3 & 0x7) 
14389                                       /* index at 16 */ < 8)) { 
14390                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
14391                                 nextPC = 4 + MATCH_p; 
14392                                 
14393 #line 1907 "frontend/machine/pentium/decoder.m"
14394                                 
14395 
14396                                         stmts = instantiate(pc,  "FISTP64", DIS_MEM64);
14397 
14398                                 
14399 
14400                                 
14401                                 
14402                                 
14403                               } /*opt-block*//*opt-block+*/
14404                               else 
14405                                 goto MATCH_label_c1241;  /*opt-block+*/
14406                               
14407                               break;
14408                             case 2: 
14409                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
14410                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
14411                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14412                                       /* index at 16 */ && 
14413                                 (MATCH_w_8_16 >> 3 & 0x7) 
14414                                       /* index at 16 */ < 8)) 
14415                                 goto MATCH_label_c1242;  /*opt-block+*/
14416                               else 
14417                                 goto MATCH_label_c1243;  /*opt-block+*/
14418                               
14419                               break;
14420                             case 3: 
14421                               goto MATCH_label_c64; break;
14422                             default: assert(0);
14423                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
14424                         break;
14425                       default: assert(0);
14426                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
14427                   
14428                   break;
14429                 default: assert(0);
14430               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
14431             break;
14432           case 14: 
14433             
14434               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
14435                 case 0: 
14436                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
14437                   { 
14438                     unsigned relocd = 
14439                       5 + MATCH_w_32_8 /* i32 at 8 */ + addressToPC(MATCH_p);
14440                     nextPC = 5 + MATCH_p; 
14441                     
14442 #line 1283 "frontend/machine/pentium/decoder.m"
14443                     
14444 
14445                             stmts = instantiate(pc,  "CALL.Jvod", dis_Num(relocd));
14446 
14447                             // Fix the last assignment, which is now %pc := %pc + (K + hostPC)
14448 
14449                             Assign* last = (Assign*)stmts->back();
14450 
14451                             Const* reloc = (Const*)((Binary*)last->getRight())->getSubExp2();
14452 
14453                             assert(reloc->isIntConst());
14454 
14455                             // Subtract off the host pc
14456 
14457                             reloc->setInt(reloc->getInt() - hostPC);
14458 
14459                             ADDRESS nativeDest = relocd-delta;
14460 
14461                             
14462 
14463                             if (nativeDest == pc+5) {
14464 
14465                                 // This is a call $+5
14466 
14467                                 // Use the standard semantics, except for the last statement
14468 
14469                                 // (just updates %pc)
14470 
14471                                 stmts->pop_back();
14472 
14473                                 // And don't make it a call statement
14474 
14475                             } else {
14476 
14477                                 CallStatement* call = new CallStatement;
14478 
14479                                 // Set the destination
14480 
14481                                 call->setDest(nativeDest);
14482 
14483                                 stmts->push_back(call);
14484 
14485                                 Proc* destProc = prog->setNewProc(nativeDest);
14486 
14487                                 if (destProc == (Proc*)-1) destProc = NULL;     // In case a deleted Proc
14488 
14489                                 call->setDestProc(destProc);
14490 
14491                             }
14492 
14493                             result.rtl = new RTL(pc, stmts);
14494 
14495                     
14496 
14497                     
14498                     
14499                     
14500                   }
14501                   
14502                   break;
14503                 case 1: 
14504                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
14505                   MATCH_name = 
14506                     MATCH_name_col_59[(MATCH_w_8_0 & 0x7) /* col at 0 */]; 
14507                   { 
14508                     char *name = MATCH_name;
14509                     unsigned relocd = 
14510                       5 + MATCH_w_32_8 /* i32 at 8 */ + addressToPC(MATCH_p);
14511                     nextPC = 5 + MATCH_p; 
14512                     
14513 #line 148 "frontend/machine/pentium/decoder.m"
14514                     
14515 
14516                             unused((int) name);
14517 
14518                             unconditionalJump(name, 5, relocd, delta, pc, stmts, result);
14519 
14520                     
14521                     
14522                     
14523                   }
14524                   
14525                   break;
14526                 case 2: case 4: case 5: case 6: case 7: 
14527                   goto MATCH_label_c64; break;
14528                 case 3: 
14529                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
14530                   MATCH_name = 
14531                     MATCH_name_col_59[(MATCH_w_8_0 & 0x7) /* col at 0 */]; 
14532                   { 
14533                     char *name = MATCH_name;
14534                     unsigned relocd = 
14535                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
14536                                   8) + addressToPC(MATCH_p);
14537                     nextPC = 2 + MATCH_p; 
14538                     
14539 #line 154 "frontend/machine/pentium/decoder.m"
14540                     
14541 
14542                             unused((int) name);
14543 
14544                             unconditionalJump(name, 2, relocd, delta, pc, stmts, result);
14545 
14546                     
14547 
14548                         /*
14549 
14550                          * Conditional branches, 8 bit offset: 7X XX
14551 
14552                          */
14553 
14554                     
14555                     
14556                     
14557                   }
14558                   
14559                   break;
14560                 default: assert(0);
14561               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
14562             break;
14563           case 15: 
14564             
14565               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
14566                 case 0: 
14567                   nextPC = 1 + MATCH_p; 
14568                   
14569 #line 1268 "frontend/machine/pentium/decoder.m"
14570                   
14571 
14572                         stmts = instantiate(pc,  "CLC");
14573 
14574                   
14575 
14576                   
14577                   
14578                   
14579                   
14580                   break;
14581                 case 1: 
14582                   nextPC = 1 + MATCH_p; 
14583                   
14584 #line 423 "frontend/machine/pentium/decoder.m"
14585                   
14586 
14587                         stmts = instantiate(pc,  "STC");
14588 
14589                   
14590 
14591                   
14592                   
14593                   
14594                   
14595                   break;
14596                 case 2: 
14597                   nextPC = 1 + MATCH_p; 
14598                   
14599 #line 1262 "frontend/machine/pentium/decoder.m"
14600                   
14601 
14602                         stmts = instantiate(pc,  "CLI");
14603 
14604                   
14605 
14606                   
14607                   
14608                   
14609                   
14610                   break;
14611                 case 3: 
14612                   nextPC = 1 + MATCH_p; 
14613                   
14614 #line 417 "frontend/machine/pentium/decoder.m"
14615                   
14616 
14617                         stmts = instantiate(pc,  "STI");
14618 
14619                   
14620 
14621                   
14622                   
14623                   
14624                   
14625                   break;
14626                 case 4: 
14627                   nextPC = 1 + MATCH_p; 
14628                   
14629 #line 1265 "frontend/machine/pentium/decoder.m"
14630                   
14631 
14632                         stmts = instantiate(pc,  "CLD");
14633 
14634                   
14635 
14636                   
14637                   
14638                   
14639                   
14640                   break;
14641                 case 5: 
14642                   nextPC = 1 + MATCH_p; 
14643                   
14644 #line 420 "frontend/machine/pentium/decoder.m"
14645                   
14646 
14647                         stmts = instantiate(pc,  "STD");
14648 
14649                   
14650 
14651                   
14652                   
14653                   
14654                   
14655                   break;
14656                 case 6: 
14657                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
14658                   
14659                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
14660                       case 0: 
14661                         
14662                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
14663                             case 0: 
14664                               
14665                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
14666                                   case 0: case 1: case 2: case 3: case 6: 
14667                                   case 7: 
14668                                     goto MATCH_label_c1244; break;
14669                                   case 4: 
14670                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
14671                                     if ((MATCH_w_8_16 & 0x7) 
14672                                             /* base at 16 */ == 5 && 
14673                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14674                                             /* index at 16 */ && 
14675                                       (MATCH_w_8_16 >> 3 & 0x7) 
14676                                             /* index at 16 */ < 8)) 
14677                                       goto MATCH_label_c1246;  /*opt-block+*/
14678                                     else 
14679                                       goto MATCH_label_c1245;  /*opt-block+*/
14680                                     
14681                                     break;
14682                                   case 5: 
14683                                     goto MATCH_label_c1247; break;
14684                                   default: assert(0);
14685                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
14686                               break;
14687                             case 1: 
14688                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
14689                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
14690                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14691                                       /* index at 16 */ && 
14692                                 (MATCH_w_8_16 >> 3 & 0x7) 
14693                                       /* index at 16 */ < 8)) { 
14694                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
14695                                 nextPC = 4 + MATCH_p; 
14696                                 
14697 #line 1133 "frontend/machine/pentium/decoder.m"
14698                                 
14699 
14700                                         stmts = instantiate(pc,  "INC.Eb", DIS_EADDR8);
14701 
14702                                 
14703 
14704                                 //    | IN.eAX.DXod() =>
14705 
14706                                 //        stmts = instantiate(pc,  "IN.eAX.DXod");
14707 
14708                                 
14709 
14710                                 //    | IN.eAX.DXow() =>
14711 
14712                                 //        stmts = instantiate(pc,  "IN.eAX.DXow");
14713 
14714                                 
14715 
14716                                 //    | IN.AL.DX() =>
14717 
14718                                 //        stmts = instantiate(pc,  "IN.AL.DX");
14719 
14720                                 
14721 
14722                                 //    | IN.eAX.Ibod(i8) =>
14723 
14724                                 //        stmts = instantiate(pc,  "IN.eAX.Ibod", DIS_I8);
14725 
14726                                 
14727 
14728                                 //    | IN.eAX.Ibow(i8) =>
14729 
14730                                 //        stmts = instantiate(pc,  "IN.eAX.Ibow", DIS_I8);
14731 
14732                                 
14733 
14734                                 //    | IN.AL.Ib(i8) =>
14735 
14736                                 //        stmts = instantiate(pc,  "IN.AL.Ib", DIS_I8);
14737 
14738                                 
14739 
14740                                 
14741                                 
14742                                 
14743                               } /*opt-block*//*opt-block+*/
14744                               else 
14745                                 goto MATCH_label_c1245;  /*opt-block+*/
14746                               
14747                               break;
14748                             case 2: 
14749                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
14750                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
14751                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14752                                       /* index at 16 */ && 
14753                                 (MATCH_w_8_16 >> 3 & 0x7) 
14754                                       /* index at 16 */ < 8)) 
14755                                 goto MATCH_label_c1246;  /*opt-block+*/
14756                               else 
14757                                 goto MATCH_label_c1247;  /*opt-block+*/
14758                               
14759                               break;
14760                             case 3: 
14761                               goto MATCH_label_c1244; break;
14762                             default: assert(0);
14763                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
14764                         break;
14765                       case 1: 
14766                         
14767                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
14768                             case 0: 
14769                               
14770                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
14771                                   case 0: case 1: case 2: case 3: case 6: 
14772                                   case 7: 
14773                                     goto MATCH_label_c1248; break;
14774                                   case 4: 
14775                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
14776                                     if ((MATCH_w_8_16 & 0x7) 
14777                                             /* base at 16 */ == 5 && 
14778                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14779                                             /* index at 16 */ && 
14780                                       (MATCH_w_8_16 >> 3 & 0x7) 
14781                                             /* index at 16 */ < 8)) 
14782                                       goto MATCH_label_c1250;  /*opt-block+*/
14783                                     else 
14784                                       goto MATCH_label_c1249;  /*opt-block+*/
14785                                     
14786                                     break;
14787                                   case 5: 
14788                                     goto MATCH_label_c1251; break;
14789                                   default: assert(0);
14790                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
14791                               break;
14792                             case 1: 
14793                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
14794                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
14795                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14796                                       /* index at 16 */ && 
14797                                 (MATCH_w_8_16 >> 3 & 0x7) 
14798                                       /* index at 16 */ < 8)) { 
14799                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
14800                                 nextPC = 4 + MATCH_p; 
14801                                 
14802 #line 1217 "frontend/machine/pentium/decoder.m"
14803                                 
14804 
14805                                         stmts = instantiate(pc,  "DEC.Eb", DIS_EADDR8);
14806 
14807                                 
14808 
14809                                 
14810                                 
14811                                 
14812                               } /*opt-block*//*opt-block+*/
14813                               else 
14814                                 goto MATCH_label_c1249;  /*opt-block+*/
14815                               
14816                               break;
14817                             case 2: 
14818                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
14819                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
14820                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14821                                       /* index at 16 */ && 
14822                                 (MATCH_w_8_16 >> 3 & 0x7) 
14823                                       /* index at 16 */ < 8)) 
14824                                 goto MATCH_label_c1250;  /*opt-block+*/
14825                               else 
14826                                 goto MATCH_label_c1251;  /*opt-block+*/
14827                               
14828                               break;
14829                             case 3: 
14830                               goto MATCH_label_c1248; break;
14831                             default: assert(0);
14832                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
14833                         break;
14834                       case 2: case 3: case 4: case 5: case 6: case 7: 
14835                         goto MATCH_label_c64; break;
14836                       default: assert(0);
14837                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
14838                   
14839                   break;
14840                 case 7: 
14841                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
14842                   
14843                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
14844                       case 0: 
14845                         
14846                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
14847                             case 0: 
14848                               
14849                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
14850                                   case 0: case 1: case 2: case 3: case 6: 
14851                                   case 7: 
14852                                     goto MATCH_label_c1252; break;
14853                                   case 4: 
14854                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
14855                                     if ((MATCH_w_8_16 & 0x7) 
14856                                             /* base at 16 */ == 5 && 
14857                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14858                                             /* index at 16 */ && 
14859                                       (MATCH_w_8_16 >> 3 & 0x7) 
14860                                             /* index at 16 */ < 8)) 
14861                                       goto MATCH_label_c1254;  /*opt-block+*/
14862                                     else 
14863                                       goto MATCH_label_c1253;  /*opt-block+*/
14864                                     
14865                                     break;
14866                                   case 5: 
14867                                     goto MATCH_label_c1255; break;
14868                                   default: assert(0);
14869                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
14870                               break;
14871                             case 1: 
14872                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
14873                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
14874                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14875                                       /* index at 16 */ && 
14876                                 (MATCH_w_8_16 >> 3 & 0x7) 
14877                                       /* index at 16 */ < 8)) { 
14878                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
14879                                 nextPC = 4 + MATCH_p; 
14880                                 
14881 #line 1127 "frontend/machine/pentium/decoder.m"
14882                                 
14883 
14884                                         stmts = instantiate(pc,  "INC.Evod", DIS_EADDR32);
14885 
14886                                 
14887 
14888                                 
14889                                 
14890                                 
14891                               } /*opt-block*//*opt-block+*/
14892                               else 
14893                                 goto MATCH_label_c1253;  /*opt-block+*/
14894                               
14895                               break;
14896                             case 2: 
14897                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
14898                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
14899                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14900                                       /* index at 16 */ && 
14901                                 (MATCH_w_8_16 >> 3 & 0x7) 
14902                                       /* index at 16 */ < 8)) 
14903                                 goto MATCH_label_c1254;  /*opt-block+*/
14904                               else 
14905                                 goto MATCH_label_c1255;  /*opt-block+*/
14906                               
14907                               break;
14908                             case 3: 
14909                               goto MATCH_label_c1252; break;
14910                             default: assert(0);
14911                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
14912                         break;
14913                       case 1: 
14914                         
14915                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
14916                             case 0: 
14917                               
14918                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
14919                                   case 0: case 1: case 2: case 3: case 6: 
14920                                   case 7: 
14921                                     goto MATCH_label_c1256; break;
14922                                   case 4: 
14923                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
14924                                     if ((MATCH_w_8_16 & 0x7) 
14925                                             /* base at 16 */ == 5 && 
14926                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14927                                             /* index at 16 */ && 
14928                                       (MATCH_w_8_16 >> 3 & 0x7) 
14929                                             /* index at 16 */ < 8)) 
14930                                       goto MATCH_label_c1258;  /*opt-block+*/
14931                                     else 
14932                                       goto MATCH_label_c1257;  /*opt-block+*/
14933                                     
14934                                     break;
14935                                   case 5: 
14936                                     goto MATCH_label_c1259; break;
14937                                   default: assert(0);
14938                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
14939                               break;
14940                             case 1: 
14941                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
14942                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
14943                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14944                                       /* index at 16 */ && 
14945                                 (MATCH_w_8_16 >> 3 & 0x7) 
14946                                       /* index at 16 */ < 8)) { 
14947                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
14948                                 nextPC = 4 + MATCH_p; 
14949                                 
14950 #line 1211 "frontend/machine/pentium/decoder.m"
14951                                 
14952 
14953                                         stmts = instantiate(pc,  "DEC.Evod", DIS_EADDR32);
14954 
14955                                 
14956 
14957                                 
14958                                 
14959                                 
14960                               } /*opt-block*//*opt-block+*/
14961                               else 
14962                                 goto MATCH_label_c1257;  /*opt-block+*/
14963                               
14964                               break;
14965                             case 2: 
14966                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
14967                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
14968                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14969                                       /* index at 16 */ && 
14970                                 (MATCH_w_8_16 >> 3 & 0x7) 
14971                                       /* index at 16 */ < 8)) 
14972                                 goto MATCH_label_c1258;  /*opt-block+*/
14973                               else 
14974                                 goto MATCH_label_c1259;  /*opt-block+*/
14975                               
14976                               break;
14977                             case 3: 
14978                               goto MATCH_label_c1256; break;
14979                             default: assert(0);
14980                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
14981                         break;
14982                       case 2: 
14983                         
14984                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
14985                             case 0: 
14986                               
14987                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
14988                                   case 0: case 1: case 2: case 3: case 6: 
14989                                   case 7: 
14990                                     goto MATCH_label_c1260; break;
14991                                   case 4: 
14992                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
14993                                     if ((MATCH_w_8_16 & 0x7) 
14994                                             /* base at 16 */ == 5 && 
14995                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
14996                                             /* index at 16 */ && 
14997                                       (MATCH_w_8_16 >> 3 & 0x7) 
14998                                             /* index at 16 */ < 8)) 
14999                                       goto MATCH_label_c1262;  /*opt-block+*/
15000                                     else 
15001                                       goto MATCH_label_c1261;  /*opt-block+*/
15002                                     
15003                                     break;
15004                                   case 5: 
15005                                     goto MATCH_label_c1263; break;
15006                                   default: assert(0);
15007                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
15008                               break;
15009                             case 1: 
15010                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
15011                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15012                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15013                                       /* index at 16 */ && 
15014                                 (MATCH_w_8_16 >> 3 & 0x7) 
15015                                       /* index at 16 */ < 8)) { 
15016                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
15017                                 nextPC = 4 + MATCH_p; 
15018                                 
15019 #line 115 "frontend/machine/pentium/decoder.m"
15020                                 
15021 
15022                                         /*
15023 
15024                                          * Register call
15025 
15026                                          */
15027 
15028                                         // Mike: there should probably be a HLNwayCall class for this!
15029 
15030                                         stmts = instantiate(pc,  "CALL.Evod", DIS_EADDR32);
15031 
15032                                         CallStatement* newCall = new CallStatement;
15033 
15034                                         // Record the fact that this is a computed call
15035 
15036                                         newCall->setIsComputed();
15037 
15038                                         // Set the destination expression
15039 
15040                                         newCall->setDest(DIS_EADDR32);
15041 
15042                                         result.rtl = new RTL(pc, stmts);
15043 
15044                                         result.rtl->appendStmt(newCall);
15045 
15046                                         // Only one instruction, so size of result is size of this decode
15047 
15048                                         //result.numBytes = nextPC - hostPC;
15049 
15050                                 
15051 
15052                                 
15053                                 
15054                                 
15055                               } /*opt-block*//*opt-block+*/
15056                               else 
15057                                 goto MATCH_label_c1261;  /*opt-block+*/
15058                               
15059                               break;
15060                             case 2: 
15061                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
15062                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15063                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15064                                       /* index at 16 */ && 
15065                                 (MATCH_w_8_16 >> 3 & 0x7) 
15066                                       /* index at 16 */ < 8)) 
15067                                 goto MATCH_label_c1262;  /*opt-block+*/
15068                               else 
15069                                 goto MATCH_label_c1263;  /*opt-block+*/
15070                               
15071                               break;
15072                             case 3: 
15073                               goto MATCH_label_c1260; break;
15074                             default: assert(0);
15075                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
15076                         break;
15077                       case 3: case 5: case 7: 
15078                         goto MATCH_label_c64; break;
15079                       case 4: 
15080                         
15081                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
15082                             case 0: 
15083                               
15084                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
15085                                   case 0: case 1: case 2: case 3: case 6: 
15086                                   case 7: 
15087                                     goto MATCH_label_c1264; break;
15088                                   case 4: 
15089                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
15090                                     if ((MATCH_w_8_16 & 0x7) 
15091                                             /* base at 16 */ == 5 && 
15092                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15093                                             /* index at 16 */ && 
15094                                       (MATCH_w_8_16 >> 3 & 0x7) 
15095                                             /* index at 16 */ < 8)) 
15096                                       goto MATCH_label_c1266;  /*opt-block+*/
15097                                     else 
15098                                       goto MATCH_label_c1265;  /*opt-block+*/
15099                                     
15100                                     break;
15101                                   case 5: 
15102                                     goto MATCH_label_c1267; break;
15103                                   default: assert(0);
15104                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
15105                               break;
15106                             case 1: 
15107                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
15108                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15109                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15110                                       /* index at 16 */ && 
15111                                 (MATCH_w_8_16 >> 3 & 0x7) 
15112                                       /* index at 16 */ < 8)) { 
15113                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
15114                                 nextPC = 4 + MATCH_p; 
15115                                 
15116 #line 131 "frontend/machine/pentium/decoder.m"
15117                                 
15118 
15119                                         /*
15120 
15121                                          * Register jump
15122 
15123                                          */
15124 
15125                                         CaseStatement* newJump = new CaseStatement;
15126 
15127                                         // Record the fact that this is a computed call
15128 
15129                                         newJump->setIsComputed();
15130 
15131                                         // Set the destination expression
15132 
15133                                         newJump->setDest(DIS_EADDR32);
15134 
15135                                         result.rtl = new RTL(pc, stmts);
15136 
15137                                         result.rtl->appendStmt(newJump);
15138 
15139                                         // Only one instruction, so size of result is size of this decode
15140 
15141                                         //result.numBytes = nextPC - hostPC;
15142 
15143                                     
15144 
15145                                     /*
15146 
15147                                      * Unconditional branches
15148 
15149                                      */
15150 
15151                                 
15152                                 
15153                                 
15154                               } /*opt-block*//*opt-block+*/
15155                               else 
15156                                 goto MATCH_label_c1265;  /*opt-block+*/
15157                               
15158                               break;
15159                             case 2: 
15160                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
15161                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15162                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15163                                       /* index at 16 */ && 
15164                                 (MATCH_w_8_16 >> 3 & 0x7) 
15165                                       /* index at 16 */ < 8)) 
15166                                 goto MATCH_label_c1266;  /*opt-block+*/
15167                               else 
15168                                 goto MATCH_label_c1267;  /*opt-block+*/
15169                               
15170                               break;
15171                             case 3: 
15172                               goto MATCH_label_c1264; break;
15173                             default: assert(0);
15174                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
15175                         break;
15176                       case 6: 
15177                         
15178                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
15179                             case 0: 
15180                               
15181                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
15182                                   case 0: case 1: case 2: case 3: case 6: 
15183                                   case 7: 
15184                                     goto MATCH_label_c1268; break;
15185                                   case 4: 
15186                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
15187                                     if ((MATCH_w_8_16 & 0x7) 
15188                                             /* base at 16 */ == 5 && 
15189                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15190                                             /* index at 16 */ && 
15191                                       (MATCH_w_8_16 >> 3 & 0x7) 
15192                                             /* index at 16 */ < 8)) 
15193                                       goto MATCH_label_c1270;  /*opt-block+*/
15194                                     else 
15195                                       goto MATCH_label_c1269;  /*opt-block+*/
15196                                     
15197                                     break;
15198                                   case 5: 
15199                                     goto MATCH_label_c1271; break;
15200                                   default: assert(0);
15201                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
15202                               break;
15203                             case 1: 
15204                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
15205                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15206                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15207                                       /* index at 16 */ && 
15208                                 (MATCH_w_8_16 >> 3 & 0x7) 
15209                                       /* index at 16 */ < 8)) { 
15210                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
15211                                 nextPC = 4 + MATCH_p; 
15212                                 
15213 #line 838 "frontend/machine/pentium/decoder.m"
15214                                 
15215 
15216                                         stmts = instantiate(pc,  "PUSH.Evod", DIS_EADDR32);
15217 
15218                                 
15219 
15220                                 
15221                                 
15222                                 
15223                               } /*opt-block*//*opt-block+*/
15224                               else 
15225                                 goto MATCH_label_c1269;  /*opt-block+*/
15226                               
15227                               break;
15228                             case 2: 
15229                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
15230                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15231                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15232                                       /* index at 16 */ && 
15233                                 (MATCH_w_8_16 >> 3 & 0x7) 
15234                                       /* index at 16 */ < 8)) 
15235                                 goto MATCH_label_c1270;  /*opt-block+*/
15236                               else 
15237                                 goto MATCH_label_c1271;  /*opt-block+*/
15238                               
15239                               break;
15240                             case 3: 
15241                               goto MATCH_label_c1268; break;
15242                             default: assert(0);
15243                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
15244                         break;
15245                       default: assert(0);
15246                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
15247                   
15248                   break;
15249                 default: assert(0);
15250               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
15251             break;
15252           default: assert(0);
15253         } /* (MATCH_w_8_0 >> 4 & 0xf) -- row at 0 --*/  
15254     else 
15255       
15256         switch((MATCH_w_8_0 >> 4 & 0xf) /* row at 0 */) {
15257           case 0: 
15258             
15259               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
15260                 case 0: 
15261                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
15262                   
15263                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
15264                       case 0: 
15265                         
15266                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
15267                             case 0: case 1: case 2: case 3: case 6: case 7: 
15268                               goto MATCH_label_c0; break;
15269                             case 4: 
15270                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
15271                               if ((MATCH_w_8_16 & 0x7) 
15272                                       /* base at 16 */ == 5 && 
15273                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15274                                       /* index at 16 */ && 
15275                                 (MATCH_w_8_16 >> 3 & 0x7) 
15276                                       /* index at 16 */ < 8)) 
15277                                 goto MATCH_label_c2;  /*opt-block+*/
15278                               else 
15279                                 goto MATCH_label_c1;  /*opt-block+*/
15280                               
15281                               break;
15282                             case 5: 
15283                               goto MATCH_label_c3; break;
15284                             default: assert(0);
15285                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
15286                         break;
15287                       case 1: 
15288                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
15289                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15290                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15291                                 /* index at 16 */ && 
15292                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
15293                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
15294                           unsigned r8 = 
15295                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
15296                           nextPC = 4 + MATCH_p; 
15297                           
15298 #line 1546 "frontend/machine/pentium/decoder.m"
15299                           
15300 
15301                                 stmts = instantiate(pc,  "ADDmrb", DIS_EADDR8, DIS_R8);
15302 
15303                           
15304 
15305                           
15306                           
15307                           
15308                         } /*opt-block*//*opt-block+*/
15309                         else 
15310                           goto MATCH_label_c1;  /*opt-block+*/
15311                         
15312                         break;
15313                       case 2: 
15314                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
15315                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15316                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15317                                 /* index at 16 */ && 
15318                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
15319                           goto MATCH_label_c2;  /*opt-block+*/
15320                         else 
15321                           goto MATCH_label_c3;  /*opt-block+*/
15322                         
15323                         break;
15324                       case 3: 
15325                         goto MATCH_label_c0; break;
15326                       default: assert(0);
15327                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
15328                   
15329                   break;
15330                 case 1: 
15331                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
15332                   
15333                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
15334                       case 0: 
15335                         
15336                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
15337                             case 0: case 1: case 2: case 3: case 6: case 7: 
15338                               goto MATCH_label_c4; break;
15339                             case 4: 
15340                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
15341                               if ((MATCH_w_8_16 & 0x7) 
15342                                       /* base at 16 */ == 5 && 
15343                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15344                                       /* index at 16 */ && 
15345                                 (MATCH_w_8_16 >> 3 & 0x7) 
15346                                       /* index at 16 */ < 8)) 
15347                                 goto MATCH_label_c6;  /*opt-block+*/
15348                               else 
15349                                 goto MATCH_label_c5;  /*opt-block+*/
15350                               
15351                               break;
15352                             case 5: 
15353                               goto MATCH_label_c7; break;
15354                             default: assert(0);
15355                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
15356                         break;
15357                       case 1: 
15358                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
15359                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15360                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15361                                 /* index at 16 */ && 
15362                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
15363                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
15364                           unsigned reg = 
15365                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
15366                           nextPC = 4 + MATCH_p; 
15367                           
15368 #line 1519 "frontend/machine/pentium/decoder.m"
15369                           
15370 
15371                                 stmts = instantiate(pc,  "ADDmrod", DIS_EADDR32, DIS_REG32);
15372 
15373                           
15374 
15375                           
15376                           
15377                           
15378                         } /*opt-block*//*opt-block+*/
15379                         else 
15380                           goto MATCH_label_c5;  /*opt-block+*/
15381                         
15382                         break;
15383                       case 2: 
15384                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
15385                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15386                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15387                                 /* index at 16 */ && 
15388                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
15389                           goto MATCH_label_c6;  /*opt-block+*/
15390                         else 
15391                           goto MATCH_label_c7;  /*opt-block+*/
15392                         
15393                         break;
15394                       case 3: 
15395                         goto MATCH_label_c4; break;
15396                       default: assert(0);
15397                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
15398                   
15399                   break;
15400                 case 2: 
15401                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
15402                   
15403                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
15404                       case 0: 
15405                         
15406                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
15407                             case 0: case 1: case 2: case 3: case 6: case 7: 
15408                               goto MATCH_label_c8; break;
15409                             case 4: 
15410                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
15411                               if ((MATCH_w_8_16 & 0x7) 
15412                                       /* base at 16 */ == 5 && 
15413                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15414                                       /* index at 16 */ && 
15415                                 (MATCH_w_8_16 >> 3 & 0x7) 
15416                                       /* index at 16 */ < 8)) 
15417                                 goto MATCH_label_c10;  /*opt-block+*/
15418                               else 
15419                                 goto MATCH_label_c9;  /*opt-block+*/
15420                               
15421                               break;
15422                             case 5: 
15423                               goto MATCH_label_c11; break;
15424                             default: assert(0);
15425                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
15426                         break;
15427                       case 1: 
15428                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
15429                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15430                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15431                                 /* index at 16 */ && 
15432                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
15433                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
15434                           unsigned r8 = 
15435                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
15436                           nextPC = 4 + MATCH_p; 
15437                           
15438 #line 1474 "frontend/machine/pentium/decoder.m"
15439                           
15440 
15441                                 stmts = instantiate(pc,  "ADDrmb", DIS_R8, DIS_EADDR8);
15442 
15443                           
15444 
15445                           
15446                           
15447                           
15448                         } /*opt-block*//*opt-block+*/
15449                         else 
15450                           goto MATCH_label_c9;  /*opt-block+*/
15451                         
15452                         break;
15453                       case 2: 
15454                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
15455                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15456                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15457                                 /* index at 16 */ && 
15458                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
15459                           goto MATCH_label_c10;  /*opt-block+*/
15460                         else 
15461                           goto MATCH_label_c11;  /*opt-block+*/
15462                         
15463                         break;
15464                       case 3: 
15465                         goto MATCH_label_c8; break;
15466                       default: assert(0);
15467                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
15468                   
15469                   break;
15470                 case 3: 
15471                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
15472                   
15473                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
15474                       case 0: 
15475                         
15476                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
15477                             case 0: case 1: case 2: case 3: case 6: case 7: 
15478                               goto MATCH_label_c12; break;
15479                             case 4: 
15480                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
15481                               if ((MATCH_w_8_16 & 0x7) 
15482                                       /* base at 16 */ == 5 && 
15483                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15484                                       /* index at 16 */ && 
15485                                 (MATCH_w_8_16 >> 3 & 0x7) 
15486                                       /* index at 16 */ < 8)) 
15487                                 goto MATCH_label_c14;  /*opt-block+*/
15488                               else 
15489                                 goto MATCH_label_c13;  /*opt-block+*/
15490                               
15491                               break;
15492                             case 5: 
15493                               goto MATCH_label_c15; break;
15494                             default: assert(0);
15495                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
15496                         break;
15497                       case 1: 
15498                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
15499                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15500                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15501                                 /* index at 16 */ && 
15502                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
15503                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
15504                           unsigned reg = 
15505                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
15506                           nextPC = 4 + MATCH_p; 
15507                           
15508 #line 1447 "frontend/machine/pentium/decoder.m"
15509                           
15510 
15511                                 stmts = instantiate(pc,  "ADDrmod", DIS_REG32, DIS_EADDR32);
15512 
15513                           
15514 
15515                           
15516                           
15517                           
15518                         } /*opt-block*//*opt-block+*/
15519                         else 
15520                           goto MATCH_label_c13;  /*opt-block+*/
15521                         
15522                         break;
15523                       case 2: 
15524                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
15525                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15526                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15527                                 /* index at 16 */ && 
15528                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
15529                           goto MATCH_label_c14;  /*opt-block+*/
15530                         else 
15531                           goto MATCH_label_c15;  /*opt-block+*/
15532                         
15533                         break;
15534                       case 3: 
15535                         goto MATCH_label_c12; break;
15536                       default: assert(0);
15537                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
15538                   
15539                   break;
15540                 case 4: 
15541                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
15542                   { 
15543                     int /* [~128..127] */ i8 = 
15544                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
15545                     nextPC = 2 + MATCH_p; 
15546                     
15547 #line 1741 "frontend/machine/pentium/decoder.m"
15548                     
15549 
15550                             stmts = instantiate(pc,  "ADDiAL", DIS_I8);
15551 
15552                     
15553 
15554                     
15555                     
15556                     
15557                   }
15558                   
15559                   break;
15560                 case 5: 
15561                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
15562                   { 
15563                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
15564                     nextPC = 5 + MATCH_p; 
15565                     
15566 #line 1693 "frontend/machine/pentium/decoder.m"
15567                     
15568 
15569                             stmts = instantiate(pc,  "ADDiEAX", DIS_I32);
15570 
15571                     
15572 
15573                     
15574                     
15575                     
15576                   }
15577                   
15578                   break;
15579                 case 6: 
15580                   nextPC = 1 + MATCH_p; 
15581                   
15582 #line 808 "frontend/machine/pentium/decoder.m"
15583                   
15584 
15585                         stmts = instantiate(pc,  "PUSH.ES");
15586 
15587                   
15588 
15589                   
15590                   
15591                   
15592                   
15593                   break;
15594                 case 7: 
15595                   nextPC = 1 + MATCH_p; 
15596                   
15597 #line 868 "frontend/machine/pentium/decoder.m"
15598                   
15599 
15600                         stmts = instantiate(pc,  "POP.ES");
15601 
15602                   
15603 
15604                   
15605                   
15606                   
15607                   
15608                   break;
15609                 default: assert(0);
15610               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
15611             break;
15612           case 1: 
15613             
15614               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
15615                 case 0: 
15616                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
15617                   
15618                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
15619                       case 0: 
15620                         
15621                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
15622                             case 0: case 1: case 2: case 3: case 6: case 7: 
15623                               goto MATCH_label_c16; break;
15624                             case 4: 
15625                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
15626                               if ((MATCH_w_8_16 & 0x7) 
15627                                       /* base at 16 */ == 5 && 
15628                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15629                                       /* index at 16 */ && 
15630                                 (MATCH_w_8_16 >> 3 & 0x7) 
15631                                       /* index at 16 */ < 8)) 
15632                                 goto MATCH_label_c18;  /*opt-block+*/
15633                               else 
15634                                 goto MATCH_label_c17;  /*opt-block+*/
15635                               
15636                               break;
15637                             case 5: 
15638                               goto MATCH_label_c19; break;
15639                             default: assert(0);
15640                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
15641                         break;
15642                       case 1: 
15643                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
15644                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15645                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15646                                 /* index at 16 */ && 
15647                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
15648                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
15649                           unsigned r8 = 
15650                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
15651                           nextPC = 4 + MATCH_p; 
15652                           
15653 #line 1540 "frontend/machine/pentium/decoder.m"
15654                           
15655 
15656                                 stmts = instantiate(pc,  "ADCmrb", DIS_EADDR8, DIS_R8);
15657 
15658                           
15659 
15660                           
15661                           
15662                           
15663                         } /*opt-block*//*opt-block+*/
15664                         else 
15665                           goto MATCH_label_c17;  /*opt-block+*/
15666                         
15667                         break;
15668                       case 2: 
15669                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
15670                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15671                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15672                                 /* index at 16 */ && 
15673                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
15674                           goto MATCH_label_c18;  /*opt-block+*/
15675                         else 
15676                           goto MATCH_label_c19;  /*opt-block+*/
15677                         
15678                         break;
15679                       case 3: 
15680                         goto MATCH_label_c16; break;
15681                       default: assert(0);
15682                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
15683                   
15684                   break;
15685                 case 1: 
15686                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
15687                   
15688                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
15689                       case 0: 
15690                         
15691                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
15692                             case 0: case 1: case 2: case 3: case 6: case 7: 
15693                               goto MATCH_label_c20; break;
15694                             case 4: 
15695                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
15696                               if ((MATCH_w_8_16 & 0x7) 
15697                                       /* base at 16 */ == 5 && 
15698                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15699                                       /* index at 16 */ && 
15700                                 (MATCH_w_8_16 >> 3 & 0x7) 
15701                                       /* index at 16 */ < 8)) 
15702                                 goto MATCH_label_c22;  /*opt-block+*/
15703                               else 
15704                                 goto MATCH_label_c21;  /*opt-block+*/
15705                               
15706                               break;
15707                             case 5: 
15708                               goto MATCH_label_c23; break;
15709                             default: assert(0);
15710                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
15711                         break;
15712                       case 1: 
15713                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
15714                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15715                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15716                                 /* index at 16 */ && 
15717                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
15718                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
15719                           unsigned reg = 
15720                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
15721                           nextPC = 4 + MATCH_p; 
15722                           
15723 #line 1507 "frontend/machine/pentium/decoder.m"
15724                           
15725 
15726                                 stmts = instantiate(pc,  "ADCmrod", DIS_EADDR32, DIS_REG32);
15727 
15728                           
15729 
15730                           
15731                           
15732                           
15733                         } /*opt-block*//*opt-block+*/
15734                         else 
15735                           goto MATCH_label_c21;  /*opt-block+*/
15736                         
15737                         break;
15738                       case 2: 
15739                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
15740                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15741                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15742                                 /* index at 16 */ && 
15743                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
15744                           goto MATCH_label_c22;  /*opt-block+*/
15745                         else 
15746                           goto MATCH_label_c23;  /*opt-block+*/
15747                         
15748                         break;
15749                       case 3: 
15750                         goto MATCH_label_c20; break;
15751                       default: assert(0);
15752                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
15753                   
15754                   break;
15755                 case 2: 
15756                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
15757                   
15758                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
15759                       case 0: 
15760                         
15761                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
15762                             case 0: case 1: case 2: case 3: case 6: case 7: 
15763                               goto MATCH_label_c24; break;
15764                             case 4: 
15765                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
15766                               if ((MATCH_w_8_16 & 0x7) 
15767                                       /* base at 16 */ == 5 && 
15768                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15769                                       /* index at 16 */ && 
15770                                 (MATCH_w_8_16 >> 3 & 0x7) 
15771                                       /* index at 16 */ < 8)) 
15772                                 goto MATCH_label_c26;  /*opt-block+*/
15773                               else 
15774                                 goto MATCH_label_c25;  /*opt-block+*/
15775                               
15776                               break;
15777                             case 5: 
15778                               goto MATCH_label_c27; break;
15779                             default: assert(0);
15780                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
15781                         break;
15782                       case 1: 
15783                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
15784                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15785                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15786                                 /* index at 16 */ && 
15787                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
15788                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
15789                           unsigned r8 = 
15790                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
15791                           nextPC = 4 + MATCH_p; 
15792                           
15793 #line 1468 "frontend/machine/pentium/decoder.m"
15794                           
15795 
15796                                 stmts = instantiate(pc,  "ADCrmb", DIS_R8, DIS_EADDR8);
15797 
15798                           
15799 
15800                           
15801                           
15802                           
15803                         } /*opt-block*//*opt-block+*/
15804                         else 
15805                           goto MATCH_label_c25;  /*opt-block+*/
15806                         
15807                         break;
15808                       case 2: 
15809                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
15810                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15811                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15812                                 /* index at 16 */ && 
15813                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
15814                           goto MATCH_label_c26;  /*opt-block+*/
15815                         else 
15816                           goto MATCH_label_c27;  /*opt-block+*/
15817                         
15818                         break;
15819                       case 3: 
15820                         goto MATCH_label_c24; break;
15821                       default: assert(0);
15822                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
15823                   
15824                   break;
15825                 case 3: 
15826                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
15827                   
15828                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
15829                       case 0: 
15830                         
15831                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
15832                             case 0: case 1: case 2: case 3: case 6: case 7: 
15833                               goto MATCH_label_c28; break;
15834                             case 4: 
15835                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
15836                               if ((MATCH_w_8_16 & 0x7) 
15837                                       /* base at 16 */ == 5 && 
15838                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15839                                       /* index at 16 */ && 
15840                                 (MATCH_w_8_16 >> 3 & 0x7) 
15841                                       /* index at 16 */ < 8)) 
15842                                 goto MATCH_label_c30;  /*opt-block+*/
15843                               else 
15844                                 goto MATCH_label_c29;  /*opt-block+*/
15845                               
15846                               break;
15847                             case 5: 
15848                               goto MATCH_label_c31; break;
15849                             default: assert(0);
15850                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
15851                         break;
15852                       case 1: 
15853                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
15854                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15855                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15856                                 /* index at 16 */ && 
15857                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
15858                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
15859                           unsigned reg = 
15860                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
15861                           nextPC = 4 + MATCH_p; 
15862                           
15863 #line 1435 "frontend/machine/pentium/decoder.m"
15864                           
15865 
15866                                 stmts = instantiate(pc,  "ADCrmod", DIS_REG32, DIS_EADDR32);
15867 
15868                           
15869 
15870                           
15871                           
15872                           
15873                         } /*opt-block*//*opt-block+*/
15874                         else 
15875                           goto MATCH_label_c29;  /*opt-block+*/
15876                         
15877                         break;
15878                       case 2: 
15879                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
15880                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
15881                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15882                                 /* index at 16 */ && 
15883                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
15884                           goto MATCH_label_c30;  /*opt-block+*/
15885                         else 
15886                           goto MATCH_label_c31;  /*opt-block+*/
15887                         
15888                         break;
15889                       case 3: 
15890                         goto MATCH_label_c28; break;
15891                       default: assert(0);
15892                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
15893                   
15894                   break;
15895                 case 4: 
15896                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
15897                   { 
15898                     int /* [~128..127] */ i8 = 
15899                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
15900                     nextPC = 2 + MATCH_p; 
15901                     
15902 #line 1735 "frontend/machine/pentium/decoder.m"
15903                     
15904 
15905                             stmts = instantiate(pc,  "ADCiAL", DIS_I8);
15906 
15907                     
15908 
15909                     
15910                     
15911                     
15912                   }
15913                   
15914                   break;
15915                 case 5: 
15916                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
15917                   { 
15918                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
15919                     nextPC = 5 + MATCH_p; 
15920                     
15921 #line 1687 "frontend/machine/pentium/decoder.m"
15922                     
15923 
15924                             stmts = instantiate(pc,  "ADCiEAX", DIS_I32);
15925 
15926                     
15927 
15928                     
15929                     
15930                     
15931                   }
15932                   
15933                   break;
15934                 case 6: 
15935                   nextPC = 1 + MATCH_p; 
15936                   
15937 #line 814 "frontend/machine/pentium/decoder.m"
15938                   
15939 
15940                         stmts = instantiate(pc,  "PUSH.SS");
15941 
15942                   
15943 
15944                   
15945                   
15946                   
15947                   
15948                   break;
15949                 case 7: 
15950                   nextPC = 1 + MATCH_p; 
15951                   
15952 #line 865 "frontend/machine/pentium/decoder.m"
15953                   
15954 
15955                         stmts = instantiate(pc,  "POP.SS");
15956 
15957                   
15958 
15959                   
15960                   
15961                   
15962                   
15963                   break;
15964                 default: assert(0);
15965               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
15966             break;
15967           case 2: 
15968             
15969               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
15970                 case 0: 
15971                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
15972                   
15973                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
15974                       case 0: 
15975                         
15976                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
15977                             case 0: case 1: case 2: case 3: case 6: case 7: 
15978                               goto MATCH_label_c32; break;
15979                             case 4: 
15980                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
15981                               if ((MATCH_w_8_16 & 0x7) 
15982                                       /* base at 16 */ == 5 && 
15983                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
15984                                       /* index at 16 */ && 
15985                                 (MATCH_w_8_16 >> 3 & 0x7) 
15986                                       /* index at 16 */ < 8)) 
15987                                 goto MATCH_label_c34;  /*opt-block+*/
15988                               else 
15989                                 goto MATCH_label_c33;  /*opt-block+*/
15990                               
15991                               break;
15992                             case 5: 
15993                               goto MATCH_label_c35; break;
15994                             default: assert(0);
15995                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
15996                         break;
15997                       case 1: 
15998                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
15999                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
16000                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16001                                 /* index at 16 */ && 
16002                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
16003                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
16004                           unsigned r8 = 
16005                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
16006                           nextPC = 4 + MATCH_p; 
16007                           
16008 #line 1534 "frontend/machine/pentium/decoder.m"
16009                           
16010 
16011                                 stmts = instantiate(pc,  "ANDmrb", DIS_EADDR8, DIS_R8);
16012 
16013                           
16014 
16015                           
16016                           
16017                           
16018                         } /*opt-block*//*opt-block+*/
16019                         else 
16020                           goto MATCH_label_c33;  /*opt-block+*/
16021                         
16022                         break;
16023                       case 2: 
16024                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
16025                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
16026                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16027                                 /* index at 16 */ && 
16028                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
16029                           goto MATCH_label_c34;  /*opt-block+*/
16030                         else 
16031                           goto MATCH_label_c35;  /*opt-block+*/
16032                         
16033                         break;
16034                       case 3: 
16035                         goto MATCH_label_c32; break;
16036                       default: assert(0);
16037                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
16038                   
16039                   break;
16040                 case 1: 
16041                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
16042                   
16043                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
16044                       case 0: 
16045                         
16046                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
16047                             case 0: case 1: case 2: case 3: case 6: case 7: 
16048                               goto MATCH_label_c36; break;
16049                             case 4: 
16050                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
16051                               if ((MATCH_w_8_16 & 0x7) 
16052                                       /* base at 16 */ == 5 && 
16053                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16054                                       /* index at 16 */ && 
16055                                 (MATCH_w_8_16 >> 3 & 0x7) 
16056                                       /* index at 16 */ < 8)) 
16057                                 goto MATCH_label_c38;  /*opt-block+*/
16058                               else 
16059                                 goto MATCH_label_c37;  /*opt-block+*/
16060                               
16061                               break;
16062                             case 5: 
16063                               goto MATCH_label_c39; break;
16064                             default: assert(0);
16065                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
16066                         break;
16067                       case 1: 
16068                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
16069                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
16070                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16071                                 /* index at 16 */ && 
16072                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
16073                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
16074                           unsigned reg = 
16075                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
16076                           nextPC = 4 + MATCH_p; 
16077                           
16078 #line 1495 "frontend/machine/pentium/decoder.m"
16079                           
16080 
16081                                 stmts = instantiate(pc,  "ANDmrod", DIS_EADDR32, DIS_REG32);
16082 
16083                           
16084 
16085                           
16086                           
16087                           
16088                         } /*opt-block*//*opt-block+*/
16089                         else 
16090                           goto MATCH_label_c37;  /*opt-block+*/
16091                         
16092                         break;
16093                       case 2: 
16094                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
16095                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
16096                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16097                                 /* index at 16 */ && 
16098                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
16099                           goto MATCH_label_c38;  /*opt-block+*/
16100                         else 
16101                           goto MATCH_label_c39;  /*opt-block+*/
16102                         
16103                         break;
16104                       case 3: 
16105                         goto MATCH_label_c36; break;
16106                       default: assert(0);
16107                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
16108                   
16109                   break;
16110                 case 2: 
16111                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
16112                   
16113                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
16114                       case 0: 
16115                         
16116                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
16117                             case 0: case 1: case 2: case 3: case 6: case 7: 
16118                               goto MATCH_label_c40; break;
16119                             case 4: 
16120                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
16121                               if ((MATCH_w_8_16 & 0x7) 
16122                                       /* base at 16 */ == 5 && 
16123                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16124                                       /* index at 16 */ && 
16125                                 (MATCH_w_8_16 >> 3 & 0x7) 
16126                                       /* index at 16 */ < 8)) 
16127                                 goto MATCH_label_c42;  /*opt-block+*/
16128                               else 
16129                                 goto MATCH_label_c41;  /*opt-block+*/
16130                               
16131                               break;
16132                             case 5: 
16133                               goto MATCH_label_c43; break;
16134                             default: assert(0);
16135                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
16136                         break;
16137                       case 1: 
16138                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
16139                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
16140                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16141                                 /* index at 16 */ && 
16142                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
16143                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
16144                           unsigned r8 = 
16145                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
16146                           nextPC = 4 + MATCH_p; 
16147                           
16148 #line 1462 "frontend/machine/pentium/decoder.m"
16149                           
16150 
16151                                 stmts = instantiate(pc,  "ANDrmb", DIS_R8, DIS_EADDR8);
16152 
16153                           
16154 
16155                           
16156                           
16157                           
16158                         } /*opt-block*//*opt-block+*/
16159                         else 
16160                           goto MATCH_label_c41;  /*opt-block+*/
16161                         
16162                         break;
16163                       case 2: 
16164                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
16165                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
16166                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16167                                 /* index at 16 */ && 
16168                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
16169                           goto MATCH_label_c42;  /*opt-block+*/
16170                         else 
16171                           goto MATCH_label_c43;  /*opt-block+*/
16172                         
16173                         break;
16174                       case 3: 
16175                         goto MATCH_label_c40; break;
16176                       default: assert(0);
16177                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
16178                   
16179                   break;
16180                 case 3: 
16181                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
16182                   
16183                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
16184                       case 0: 
16185                         
16186                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
16187                             case 0: case 1: case 2: case 3: case 6: case 7: 
16188                               goto MATCH_label_c44; break;
16189                             case 4: 
16190                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
16191                               if ((MATCH_w_8_16 & 0x7) 
16192                                       /* base at 16 */ == 5 && 
16193                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16194                                       /* index at 16 */ && 
16195                                 (MATCH_w_8_16 >> 3 & 0x7) 
16196                                       /* index at 16 */ < 8)) 
16197                                 goto MATCH_label_c46;  /*opt-block+*/
16198                               else 
16199                                 goto MATCH_label_c45;  /*opt-block+*/
16200                               
16201                               break;
16202                             case 5: 
16203                               goto MATCH_label_c47; break;
16204                             default: assert(0);
16205                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
16206                         break;
16207                       case 1: 
16208                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
16209                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
16210                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16211                                 /* index at 16 */ && 
16212                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
16213                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
16214                           unsigned reg = 
16215                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
16216                           nextPC = 4 + MATCH_p; 
16217                           
16218 #line 1423 "frontend/machine/pentium/decoder.m"
16219                           
16220 
16221                                 stmts = instantiate(pc,  "ANDrmod", DIS_REG32, DIS_EADDR32);
16222 
16223                           
16224 
16225                           
16226                           
16227                           
16228                         } /*opt-block*//*opt-block+*/
16229                         else 
16230                           goto MATCH_label_c45;  /*opt-block+*/
16231                         
16232                         break;
16233                       case 2: 
16234                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
16235                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
16236                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16237                                 /* index at 16 */ && 
16238                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
16239                           goto MATCH_label_c46;  /*opt-block+*/
16240                         else 
16241                           goto MATCH_label_c47;  /*opt-block+*/
16242                         
16243                         break;
16244                       case 3: 
16245                         goto MATCH_label_c44; break;
16246                       default: assert(0);
16247                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
16248                   
16249                   break;
16250                 case 4: 
16251                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
16252                   { 
16253                     int /* [~128..127] */ i8 = 
16254                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
16255                     nextPC = 2 + MATCH_p; 
16256                     
16257 #line 1729 "frontend/machine/pentium/decoder.m"
16258                     
16259 
16260                             stmts = instantiate(pc,  "ANDiAL", DIS_I8);
16261 
16262                     
16263 
16264                     
16265                     
16266                     
16267                   }
16268                   
16269                   break;
16270                 case 5: 
16271                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
16272                   { 
16273                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
16274                     nextPC = 5 + MATCH_p; 
16275                     
16276 #line 1681 "frontend/machine/pentium/decoder.m"
16277                     
16278 
16279                             stmts = instantiate(pc,  "ANDiEAX", DIS_I32);
16280 
16281                     
16282 
16283                     
16284                     
16285                     
16286                   }
16287                   
16288                   break;
16289                 case 6: 
16290                   nextPC = 1 + MATCH_p; 
16291                   
16292 #line 336 "frontend/machine/pentium/decoder.m"
16293                          // For now, treat seg.es as a 1 byte NOP
16294 
16295                         stmts = instantiate(pc,  "NOP");
16296 
16297                   
16298 
16299                   
16300                   
16301                   
16302                   
16303                   break;
16304                 case 7: 
16305                   nextPC = 1 + MATCH_p; 
16306                   
16307 #line 1223 "frontend/machine/pentium/decoder.m"
16308                   
16309 
16310                         stmts = instantiate(pc,  "DAA");
16311 
16312                   
16313 
16314                   
16315                   
16316                   
16317                   
16318                   break;
16319                 default: assert(0);
16320               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
16321             break;
16322           case 3: 
16323             
16324               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
16325                 case 0: 
16326                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
16327                   
16328                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
16329                       case 0: 
16330                         
16331                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
16332                             case 0: case 1: case 2: case 3: case 6: case 7: 
16333                               goto MATCH_label_c48; break;
16334                             case 4: 
16335                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
16336                               if ((MATCH_w_8_16 & 0x7) 
16337                                       /* base at 16 */ == 5 && 
16338                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16339                                       /* index at 16 */ && 
16340                                 (MATCH_w_8_16 >> 3 & 0x7) 
16341                                       /* index at 16 */ < 8)) 
16342                                 goto MATCH_label_c50;  /*opt-block+*/
16343                               else 
16344                                 goto MATCH_label_c49;  /*opt-block+*/
16345                               
16346                               break;
16347                             case 5: 
16348                               goto MATCH_label_c51; break;
16349                             default: assert(0);
16350                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
16351                         break;
16352                       case 1: 
16353                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
16354                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
16355                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16356                                 /* index at 16 */ && 
16357                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
16358                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
16359                           unsigned r8 = 
16360                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
16361                           nextPC = 4 + MATCH_p; 
16362                           
16363 #line 1528 "frontend/machine/pentium/decoder.m"
16364                           
16365 
16366                                 stmts = instantiate(pc,  "XORmrb", DIS_EADDR8, DIS_R8);
16367 
16368                           
16369 
16370                           
16371                           
16372                           
16373                         } /*opt-block*//*opt-block+*/
16374                         else 
16375                           goto MATCH_label_c49;  /*opt-block+*/
16376                         
16377                         break;
16378                       case 2: 
16379                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
16380                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
16381                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16382                                 /* index at 16 */ && 
16383                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
16384                           goto MATCH_label_c50;  /*opt-block+*/
16385                         else 
16386                           goto MATCH_label_c51;  /*opt-block+*/
16387                         
16388                         break;
16389                       case 3: 
16390                         goto MATCH_label_c48; break;
16391                       default: assert(0);
16392                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
16393                   
16394                   break;
16395                 case 1: 
16396                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
16397                   
16398                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
16399                       case 0: 
16400                         
16401                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
16402                             case 0: case 1: case 2: case 3: case 6: case 7: 
16403                               goto MATCH_label_c52; break;
16404                             case 4: 
16405                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
16406                               if ((MATCH_w_8_16 & 0x7) 
16407                                       /* base at 16 */ == 5 && 
16408                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16409                                       /* index at 16 */ && 
16410                                 (MATCH_w_8_16 >> 3 & 0x7) 
16411                                       /* index at 16 */ < 8)) 
16412                                 goto MATCH_label_c54;  /*opt-block+*/
16413                               else 
16414                                 goto MATCH_label_c53;  /*opt-block+*/
16415                               
16416                               break;
16417                             case 5: 
16418                               goto MATCH_label_c55; break;
16419                             default: assert(0);
16420                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
16421                         break;
16422                       case 1: 
16423                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
16424                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
16425                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16426                                 /* index at 16 */ && 
16427                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
16428                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
16429                           unsigned reg = 
16430                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
16431                           nextPC = 4 + MATCH_p; 
16432                           
16433 #line 1483 "frontend/machine/pentium/decoder.m"
16434                           
16435 
16436                                 stmts = instantiate(pc,  "XORmrod", DIS_EADDR32, DIS_REG32);
16437 
16438                           
16439 
16440                           
16441                           
16442                           
16443                         } /*opt-block*//*opt-block+*/
16444                         else 
16445                           goto MATCH_label_c53;  /*opt-block+*/
16446                         
16447                         break;
16448                       case 2: 
16449                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
16450                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
16451                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16452                                 /* index at 16 */ && 
16453                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
16454                           goto MATCH_label_c54;  /*opt-block+*/
16455                         else 
16456                           goto MATCH_label_c55;  /*opt-block+*/
16457                         
16458                         break;
16459                       case 3: 
16460                         goto MATCH_label_c52; break;
16461                       default: assert(0);
16462                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
16463                   
16464                   break;
16465                 case 2: 
16466                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
16467                   
16468                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
16469                       case 0: 
16470                         
16471                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
16472                             case 0: case 1: case 2: case 3: case 6: case 7: 
16473                               goto MATCH_label_c56; break;
16474                             case 4: 
16475                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
16476                               if ((MATCH_w_8_16 & 0x7) 
16477                                       /* base at 16 */ == 5 && 
16478                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16479                                       /* index at 16 */ && 
16480                                 (MATCH_w_8_16 >> 3 & 0x7) 
16481                                       /* index at 16 */ < 8)) 
16482                                 goto MATCH_label_c58;  /*opt-block+*/
16483                               else 
16484                                 goto MATCH_label_c57;  /*opt-block+*/
16485                               
16486                               break;
16487                             case 5: 
16488                               goto MATCH_label_c59; break;
16489                             default: assert(0);
16490                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
16491                         break;
16492                       case 1: 
16493                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
16494                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
16495                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16496                                 /* index at 16 */ && 
16497                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
16498                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
16499                           unsigned r8 = 
16500                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
16501                           nextPC = 4 + MATCH_p; 
16502                           
16503 #line 1456 "frontend/machine/pentium/decoder.m"
16504                           
16505 
16506                                 stmts = instantiate(pc,  "XORrmb", DIS_R8, DIS_EADDR8);
16507 
16508                           
16509 
16510                           
16511                           
16512                           
16513                         } /*opt-block*//*opt-block+*/
16514                         else 
16515                           goto MATCH_label_c57;  /*opt-block+*/
16516                         
16517                         break;
16518                       case 2: 
16519                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
16520                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
16521                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16522                                 /* index at 16 */ && 
16523                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
16524                           goto MATCH_label_c58;  /*opt-block+*/
16525                         else 
16526                           goto MATCH_label_c59;  /*opt-block+*/
16527                         
16528                         break;
16529                       case 3: 
16530                         goto MATCH_label_c56; break;
16531                       default: assert(0);
16532                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
16533                   
16534                   break;
16535                 case 3: 
16536                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
16537                   
16538                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
16539                       case 0: 
16540                         
16541                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
16542                             case 0: case 1: case 2: case 3: case 6: case 7: 
16543                               goto MATCH_label_c60; break;
16544                             case 4: 
16545                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
16546                               if ((MATCH_w_8_16 & 0x7) 
16547                                       /* base at 16 */ == 5 && 
16548                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16549                                       /* index at 16 */ && 
16550                                 (MATCH_w_8_16 >> 3 & 0x7) 
16551                                       /* index at 16 */ < 8)) 
16552                                 goto MATCH_label_c62;  /*opt-block+*/
16553                               else 
16554                                 goto MATCH_label_c61;  /*opt-block+*/
16555                               
16556                               break;
16557                             case 5: 
16558                               goto MATCH_label_c63; break;
16559                             default: assert(0);
16560                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
16561                         break;
16562                       case 1: 
16563                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
16564                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
16565                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16566                                 /* index at 16 */ && 
16567                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
16568                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
16569                           unsigned reg = 
16570                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
16571                           nextPC = 4 + MATCH_p; 
16572                           
16573 #line 1411 "frontend/machine/pentium/decoder.m"
16574                           
16575 
16576                                 stmts = instantiate(pc,  "XORrmod", DIS_REG32, DIS_EADDR32);
16577 
16578                           
16579 
16580                           
16581                           
16582                           
16583                         } /*opt-block*//*opt-block+*/
16584                         else 
16585                           goto MATCH_label_c61;  /*opt-block+*/
16586                         
16587                         break;
16588                       case 2: 
16589                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
16590                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
16591                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
16592                                 /* index at 16 */ && 
16593                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
16594                           goto MATCH_label_c62;  /*opt-block+*/
16595                         else 
16596                           goto MATCH_label_c63;  /*opt-block+*/
16597                         
16598                         break;
16599                       case 3: 
16600                         goto MATCH_label_c60; break;
16601                       default: assert(0);
16602                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
16603                   
16604                   break;
16605                 case 4: 
16606                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
16607                   { 
16608                     int /* [~128..127] */ i8 = 
16609                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
16610                     nextPC = 2 + MATCH_p; 
16611                     
16612 #line 1723 "frontend/machine/pentium/decoder.m"
16613                     
16614 
16615                             stmts = instantiate(pc,  "XORiAL", DIS_I8);
16616 
16617                     
16618 
16619                     
16620                     
16621                     
16622                   }
16623                   
16624                   break;
16625                 case 5: 
16626                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
16627                   { 
16628                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
16629                     nextPC = 5 + MATCH_p; 
16630                     
16631 #line 1675 "frontend/machine/pentium/decoder.m"
16632                     
16633 
16634                             stmts = instantiate(pc,  "XORiEAX", DIS_I32);
16635 
16636                     
16637 
16638                     
16639                     
16640                     
16641                   }
16642                   
16643                   break;
16644                 case 6: 
16645                   nextPC = 1 + MATCH_p; 
16646                   
16647 #line 345 "frontend/machine/pentium/decoder.m"
16648                          // For now, treat seg.ss as a 1 byte NOP
16649 
16650                         stmts = instantiate(pc,  "NOP");
16651 
16652                   
16653 
16654                   
16655                   
16656                   
16657                   
16658                   break;
16659                 case 7: 
16660                   goto MATCH_label_c64; break;
16661                 default: assert(0);
16662               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
16663             break;
16664           case 4: 
16665             { 
16666               unsigned r32 = (MATCH_w_8_0 & 0x7) /* r32 at 0 */;
16667               nextPC = 1 + MATCH_p; 
16668               
16669 #line 1121 "frontend/machine/pentium/decoder.m"
16670               
16671 
16672                     stmts = instantiate(pc,  "INCod", DIS_R32);
16673 
16674               
16675 
16676               
16677               
16678               
16679             }
16680             
16681             break;
16682           case 5: 
16683             { 
16684               unsigned r32 = (MATCH_w_8_0 & 0x7) /* r32 at 0 */;
16685               nextPC = 1 + MATCH_p; 
16686               
16687 #line 832 "frontend/machine/pentium/decoder.m"
16688               
16689 
16690                     stmts = instantiate(pc,  "PUSHod", DIS_R32);
16691 
16692               
16693 
16694               
16695               
16696               
16697             }
16698             
16699             break;
16700           case 6: 
16701             
16702               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
16703                 case 0: case 1: case 2: case 3: case 7: 
16704                   goto MATCH_label_c64; break;
16705                 case 4: 
16706                   nextPC = 1 + MATCH_p; 
16707                   
16708 #line 339 "frontend/machine/pentium/decoder.m"
16709                          // For now, treat seg.fs as a 1 byte NOP
16710 
16711                         stmts = instantiate(pc,  "NOP");
16712 
16713                   
16714 
16715                   
16716                   
16717                   
16718                   
16719                   break;
16720                 case 5: 
16721                   nextPC = 1 + MATCH_p; 
16722                   
16723 #line 342 "frontend/machine/pentium/decoder.m"
16724                          // For now, treat seg.gs as a 1 byte NOP
16725 
16726                         stmts = instantiate(pc,  "NOP");
16727 
16728                   
16729 
16730                   
16731                   
16732                   
16733                   
16734                   break;
16735                 case 6: 
16736                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
16737                   
16738                     switch((MATCH_w_8_8 >> 4 & 0xf) /* row at 8 */) {
16739                       case 0: 
16740                         
16741                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
16742                             case 0: case 2: case 4: case 6: 
16743                               goto MATCH_label_c64; break;
16744                             case 1: 
16745                               if ((MATCH_w_8_8 >> 3 & 0x1) 
16746                                       /* page at 8 */ == 1) { 
16747                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
16748                                 
16749                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
16750                                         /* mod at 16 */) {
16751                                     case 0: 
16752                                       
16753                                         switch((MATCH_w_8_16 & 0x7) 
16754                                               /* r_m at 16 */) {
16755                                           case 0: case 1: case 2: case 3: 
16756                                           case 6: case 7: 
16757                                             goto MATCH_label_c69; break;
16758                                           case 4: 
16759                                             MATCH_w_8_24 = 
16760                                               getByte(3 + MATCH_p); 
16761                                             if ((MATCH_w_8_24 & 0x7) 
16762                                                     /* base at 24 */ == 5 && 
16763                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16764                                                     /* index at 24 */ && 
16765                                               (MATCH_w_8_24 >> 3 & 0x7) 
16766                                                     /* index at 24 */ < 8)) 
16767                                               goto MATCH_label_c71;  /*opt-block+*/
16768                                             else 
16769                                               goto MATCH_label_c70;  /*opt-block+*/
16770                                             
16771                                             break;
16772                                           case 5: 
16773                                             goto MATCH_label_c72; break;
16774                                           default: assert(0);
16775                                         } /* (MATCH_w_8_16 & 0x7) 
16776                                               -- r_m at 16 --*/ 
16777                                       break;
16778                                     case 1: 
16779                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
16780                                       if ((MATCH_w_8_16 & 0x7) 
16781                                               /* r_m at 16 */ == 4 && 
16782                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16783                                               /* index at 24 */ && 
16784                                         (MATCH_w_8_24 >> 3 & 0x7) 
16785                                               /* index at 24 */ < 8)) { 
16786                                         unsigned Eaddr = 
16787                                           2 + addressToPC(MATCH_p);
16788                                         unsigned reg = 
16789                                           (MATCH_w_8_16 >> 3 & 0x7) 
16790                                                 /* reg_opcode at 16 */;
16791                                         nextPC = 5 + MATCH_p; 
16792                                         
16793 #line 1516 "frontend/machine/pentium/decoder.m"
16794                                         
16795 
16796                                                 stmts = instantiate(pc,  "ORmrow", DIS_EADDR16, DIS_REG16);
16797 
16798                                         
16799 
16800                                         
16801                                         
16802                                         
16803                                       } /*opt-block*//*opt-block+*/
16804                                       else 
16805                                         goto MATCH_label_c70;  /*opt-block+*/
16806                                       
16807                                       break;
16808                                     case 2: 
16809                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
16810                                       if ((MATCH_w_8_16 & 0x7) 
16811                                               /* r_m at 16 */ == 4 && 
16812                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16813                                               /* index at 24 */ && 
16814                                         (MATCH_w_8_24 >> 3 & 0x7) 
16815                                               /* index at 24 */ < 8)) 
16816                                         goto MATCH_label_c71;  /*opt-block+*/
16817                                       else 
16818                                         goto MATCH_label_c72;  /*opt-block+*/
16819                                       
16820                                       break;
16821                                     case 3: 
16822                                       goto MATCH_label_c69; break;
16823                                     default: assert(0);
16824                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
16825                                         -- mod at 16 --*/ 
16826                                 
16827                               } /*opt-block*/
16828                               else { 
16829                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
16830                                 
16831                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
16832                                         /* mod at 16 */) {
16833                                     case 0: 
16834                                       
16835                                         switch((MATCH_w_8_16 & 0x7) 
16836                                               /* r_m at 16 */) {
16837                                           case 0: case 1: case 2: case 3: 
16838                                           case 6: case 7: 
16839                                             goto MATCH_label_c65; break;
16840                                           case 4: 
16841                                             MATCH_w_8_24 = 
16842                                               getByte(3 + MATCH_p); 
16843                                             if ((MATCH_w_8_24 & 0x7) 
16844                                                     /* base at 24 */ == 5 && 
16845                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16846                                                     /* index at 24 */ && 
16847                                               (MATCH_w_8_24 >> 3 & 0x7) 
16848                                                     /* index at 24 */ < 8)) 
16849                                               goto MATCH_label_c67;  /*opt-block+*/
16850                                             else 
16851                                               goto MATCH_label_c66;  /*opt-block+*/
16852                                             
16853                                             break;
16854                                           case 5: 
16855                                             goto MATCH_label_c68; break;
16856                                           default: assert(0);
16857                                         } /* (MATCH_w_8_16 & 0x7) 
16858                                               -- r_m at 16 --*/ 
16859                                       break;
16860                                     case 1: 
16861                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
16862                                       if ((MATCH_w_8_16 & 0x7) 
16863                                               /* r_m at 16 */ == 4 && 
16864                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16865                                               /* index at 24 */ && 
16866                                         (MATCH_w_8_24 >> 3 & 0x7) 
16867                                               /* index at 24 */ < 8)) { 
16868                                         unsigned Eaddr = 
16869                                           2 + addressToPC(MATCH_p);
16870                                         unsigned reg = 
16871                                           (MATCH_w_8_16 >> 3 & 0x7) 
16872                                                 /* reg_opcode at 16 */;
16873                                         nextPC = 5 + MATCH_p; 
16874                                         
16875 #line 1522 "frontend/machine/pentium/decoder.m"
16876                                         
16877 
16878                                                 stmts = instantiate(pc,  "ADDmrow", DIS_EADDR16, DIS_REG16);
16879 
16880                                         
16881 
16882                                         
16883                                         
16884                                         
16885                                       } /*opt-block*//*opt-block+*/
16886                                       else 
16887                                         goto MATCH_label_c66;  /*opt-block+*/
16888                                       
16889                                       break;
16890                                     case 2: 
16891                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
16892                                       if ((MATCH_w_8_16 & 0x7) 
16893                                               /* r_m at 16 */ == 4 && 
16894                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16895                                               /* index at 24 */ && 
16896                                         (MATCH_w_8_24 >> 3 & 0x7) 
16897                                               /* index at 24 */ < 8)) 
16898                                         goto MATCH_label_c67;  /*opt-block+*/
16899                                       else 
16900                                         goto MATCH_label_c68;  /*opt-block+*/
16901                                       
16902                                       break;
16903                                     case 3: 
16904                                       goto MATCH_label_c65; break;
16905                                     default: assert(0);
16906                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
16907                                         -- mod at 16 --*/ 
16908                                 
16909                               } /*opt-block*/
16910                               break;
16911                             case 3: 
16912                               if ((MATCH_w_8_8 >> 3 & 0x1) 
16913                                       /* page at 8 */ == 1) { 
16914                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
16915                                 
16916                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
16917                                         /* mod at 16 */) {
16918                                     case 0: 
16919                                       
16920                                         switch((MATCH_w_8_16 & 0x7) 
16921                                               /* r_m at 16 */) {
16922                                           case 0: case 1: case 2: case 3: 
16923                                           case 6: case 7: 
16924                                             goto MATCH_label_c77; break;
16925                                           case 4: 
16926                                             MATCH_w_8_24 = 
16927                                               getByte(3 + MATCH_p); 
16928                                             if ((MATCH_w_8_24 & 0x7) 
16929                                                     /* base at 24 */ == 5 && 
16930                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16931                                                     /* index at 24 */ && 
16932                                               (MATCH_w_8_24 >> 3 & 0x7) 
16933                                                     /* index at 24 */ < 8)) 
16934                                               goto MATCH_label_c79;  /*opt-block+*/
16935                                             else 
16936                                               goto MATCH_label_c78;  /*opt-block+*/
16937                                             
16938                                             break;
16939                                           case 5: 
16940                                             goto MATCH_label_c80; break;
16941                                           default: assert(0);
16942                                         } /* (MATCH_w_8_16 & 0x7) 
16943                                               -- r_m at 16 --*/ 
16944                                       break;
16945                                     case 1: 
16946                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
16947                                       if ((MATCH_w_8_16 & 0x7) 
16948                                               /* r_m at 16 */ == 4 && 
16949                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16950                                               /* index at 24 */ && 
16951                                         (MATCH_w_8_24 >> 3 & 0x7) 
16952                                               /* index at 24 */ < 8)) { 
16953                                         unsigned Eaddr = 
16954                                           2 + addressToPC(MATCH_p);
16955                                         unsigned reg = 
16956                                           (MATCH_w_8_16 >> 3 & 0x7) 
16957                                                 /* reg_opcode at 16 */;
16958                                         nextPC = 5 + MATCH_p; 
16959                                         
16960 #line 1444 "frontend/machine/pentium/decoder.m"
16961                                         
16962 
16963                                                 stmts = instantiate(pc,  "ORrmow", DIS_REG16, DIS_EADDR16);
16964 
16965                                         
16966 
16967                                         
16968                                         
16969                                         
16970                                       } /*opt-block*//*opt-block+*/
16971                                       else 
16972                                         goto MATCH_label_c78;  /*opt-block+*/
16973                                       
16974                                       break;
16975                                     case 2: 
16976                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
16977                                       if ((MATCH_w_8_16 & 0x7) 
16978                                               /* r_m at 16 */ == 4 && 
16979                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16980                                               /* index at 24 */ && 
16981                                         (MATCH_w_8_24 >> 3 & 0x7) 
16982                                               /* index at 24 */ < 8)) 
16983                                         goto MATCH_label_c79;  /*opt-block+*/
16984                                       else 
16985                                         goto MATCH_label_c80;  /*opt-block+*/
16986                                       
16987                                       break;
16988                                     case 3: 
16989                                       goto MATCH_label_c77; break;
16990                                     default: assert(0);
16991                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
16992                                         -- mod at 16 --*/ 
16993                                 
16994                               } /*opt-block*/
16995                               else { 
16996                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
16997                                 
16998                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
16999                                         /* mod at 16 */) {
17000                                     case 0: 
17001                                       
17002                                         switch((MATCH_w_8_16 & 0x7) 
17003                                               /* r_m at 16 */) {
17004                                           case 0: case 1: case 2: case 3: 
17005                                           case 6: case 7: 
17006                                             goto MATCH_label_c73; break;
17007                                           case 4: 
17008                                             MATCH_w_8_24 = 
17009                                               getByte(3 + MATCH_p); 
17010                                             if ((MATCH_w_8_24 & 0x7) 
17011                                                     /* base at 24 */ == 5 && 
17012                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
17013                                                     /* index at 24 */ && 
17014                                               (MATCH_w_8_24 >> 3 & 0x7) 
17015                                                     /* index at 24 */ < 8)) 
17016                                               goto MATCH_label_c75;  /*opt-block+*/
17017                                             else 
17018                                               goto MATCH_label_c74;  /*opt-block+*/
17019                                             
17020                                             break;
17021                                           case 5: 
17022                                             goto MATCH_label_c76; break;
17023                                           default: assert(0);
17024                                         } /* (MATCH_w_8_16 & 0x7) 
17025                                               -- r_m at 16 --*/ 
17026                                       break;
17027                                     case 1: 
17028                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
17029                                       if ((MATCH_w_8_16 & 0x7) 
17030                                               /* r_m at 16 */ == 4 && 
17031                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
17032                                               /* index at 24 */ && 
17033                                         (MATCH_w_8_24 >> 3 & 0x7) 
17034                                               /* index at 24 */ < 8)) { 
17035                                         unsigned Eaddr = 
17036                                           2 + addressToPC(MATCH_p);
17037                                         unsigned reg = 
17038                                           (MATCH_w_8_16 >> 3 & 0x7) 
17039                                                 /* reg_opcode at 16 */;
17040                                         nextPC = 5 + MATCH_p; 
17041                                         
17042 #line 1450 "frontend/machine/pentium/decoder.m"
17043                                         
17044 
17045                                                 stmts = instantiate(pc,  "ADDrmow", DIS_REG16, DIS_EADDR16);
17046 
17047                                         
17048 
17049                                         
17050                                         
17051                                         
17052                                       } /*opt-block*//*opt-block+*/
17053                                       else 
17054                                         goto MATCH_label_c74;  /*opt-block+*/
17055                                       
17056                                       break;
17057                                     case 2: 
17058                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
17059                                       if ((MATCH_w_8_16 & 0x7) 
17060                                               /* r_m at 16 */ == 4 && 
17061                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
17062                                               /* index at 24 */ && 
17063                                         (MATCH_w_8_24 >> 3 & 0x7) 
17064                                               /* index at 24 */ < 8)) 
17065                                         goto MATCH_label_c75;  /*opt-block+*/
17066                                       else 
17067                                         goto MATCH_label_c76;  /*opt-block+*/
17068                                       
17069                                       break;
17070                                     case 3: 
17071                                       goto MATCH_label_c73; break;
17072                                     default: assert(0);
17073                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
17074                                         -- mod at 16 --*/ 
17075                                 
17076                               } /*opt-block*/
17077                               break;
17078                             case 5: 
17079                               if ((MATCH_w_8_8 >> 3 & 0x1) 
17080                                       /* page at 8 */ == 1) { 
17081                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
17082                                 { 
17083                                   int /* [~32768..32767] */ i16 = 
17084                                     sign_extend((MATCH_w_16_16 & 0xffff) 
17085                                                       /* i16 at 16 */, 16);
17086                                   nextPC = 4 + MATCH_p; 
17087                                   
17088 #line 1714 "frontend/machine/pentium/decoder.m"
17089                                   
17090 
17091                                         stmts = instantiate(pc,  "ORiAX", DIS_I16);
17092 
17093                                   
17094 
17095                                   
17096                                   
17097                                   
17098                                 }
17099                                 
17100                               } /*opt-block*/
17101                               else { 
17102                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
17103                                 { 
17104                                   int /* [~32768..32767] */ i16 = 
17105                                     sign_extend((MATCH_w_16_16 & 0xffff) 
17106                                                       /* i16 at 16 */, 16);
17107                                   nextPC = 4 + MATCH_p; 
17108                                   
17109 #line 1717 "frontend/machine/pentium/decoder.m"
17110                                   
17111 
17112                                         stmts = instantiate(pc,  "ADDiAX", DIS_I16);
17113 
17114                                   
17115 
17116                                   
17117                                   
17118                                   
17119                                 }
17120                                 
17121                               } /*opt-block*/
17122                               
17123                               break;
17124                             case 7: 
17125                               if ((MATCH_w_8_8 >> 3 & 0x1) 
17126                                       /* page at 8 */ == 1) { 
17127                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
17128                                 
17129                                   switch((MATCH_w_8_16 >> 4 & 0xf) 
17130                                         /* row at 16 */) {
17131                                     case 0: 
17132                                       
17133                                         switch((MATCH_w_8_16 & 0x7) 
17134                                               /* col at 16 */) {
17135                                           case 0: case 1: case 4: case 5: 
17136                                           case 6: case 7: 
17137                                             goto MATCH_label_c64; break;
17138                                           case 2: 
17139                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
17140                                                     /* page at 16 */ == 1) 
17141                                               goto MATCH_label_c64;  /*opt-block+*/
17142                                             else { 
17143                                               MATCH_w_8_24 = 
17144                                                 getByte(3 + MATCH_p); 
17145                                               
17146                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
17147                                                       /* mod at 24 */) {
17148                                                   case 0: 
17149                                                     
17150                                                       switch((MATCH_w_8_24 & 0x7) 
17151                                                             /* r_m at 24 */) {
17152                                                         case 0: case 1: 
17153                                                         case 2: case 3: 
17154                                                         case 6: case 7: 
17155                                                           goto MATCH_label_c81; 
17156                                                           
17157                                                           break;
17158                                                         case 4: 
17159                                                           MATCH_w_8_32 = 
17160                                                             getByte(4 + 
17161                                                                   MATCH_p); 
17162                                                           if ((MATCH_w_8_32 & 0x7) 
17163                                                                   /* base at 32 */ == 5 && 
17164                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
17165                                                                   /* index at 32 */ && 
17166                                                             (MATCH_w_8_32 >> 3 & 0x7) 
17167                                                                   /* index at 32 */ < 8)) 
17168                                                             goto MATCH_label_c83;  /*opt-block+*/
17169                                                           else 
17170                                                             goto MATCH_label_c82;  /*opt-block+*/
17171                                                           
17172                                                           break;
17173                                                         case 5: 
17174                                                           goto MATCH_label_c84; 
17175                                                           
17176                                                           break;
17177                                                         default: assert(0);
17178                                                       } /* (MATCH_w_8_24 & 0x7) 
17179                                                             -- r_m at 24 --*/ 
17180                                                     break;
17181                                                   case 1: 
17182                                                     MATCH_w_8_32 = 
17183                                                       getByte(4 + MATCH_p); 
17184                                                     if ((MATCH_w_8_24 & 0x7) 
17185                                                             /* r_m at 24 */ == 4 && 
17186                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
17187                                                             /* index at 32 */ && 
17188                                                       (MATCH_w_8_32 >> 3 & 0x7) 
17189                                                             /* index at 32 */ < 8)) { 
17190                                                       unsigned Eaddr = 
17191                                                         3 + 
17192                                                         addressToPC(MATCH_p);
17193                                                       unsigned reg = 
17194                                                         (MATCH_w_8_24 >> 3 & 0x7) 
17195                                                               /* reg_opcode at 24 */;
17196                                                       nextPC = 6 + MATCH_p; 
17197                                                       
17198 #line 1085 "frontend/machine/pentium/decoder.m"
17199                                                       
17200 
17201                                                             stmts = instantiate(pc,  "LAR.ow", DIS_REG16, DIS_EADDR16);
17202 
17203                                                       
17204 
17205                                                       
17206                                                       
17207                                                       
17208                                                     } /*opt-block*//*opt-block+*/
17209                                                     else 
17210                                                       goto MATCH_label_c82;  /*opt-block+*/
17211                                                     
17212                                                     break;
17213                                                   case 2: 
17214                                                     MATCH_w_8_32 = 
17215                                                       getByte(4 + MATCH_p); 
17216                                                     if ((MATCH_w_8_24 & 0x7) 
17217                                                             /* r_m at 24 */ == 4 && 
17218                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
17219                                                             /* index at 32 */ && 
17220                                                       (MATCH_w_8_32 >> 3 & 0x7) 
17221                                                             /* index at 32 */ < 8)) 
17222                                                       goto MATCH_label_c83;  /*opt-block+*/
17223                                                     else 
17224                                                       goto MATCH_label_c84;  /*opt-block+*/
17225                                                     
17226                                                     break;
17227                                                   case 3: 
17228                                                     goto MATCH_label_c81; 
17229                                                     
17230                                                     break;
17231                                                   default: assert(0);
17232                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
17233                                                       -- mod at 24 --*/ 
17234                                               
17235                                             } /*opt-block*/
17236                                             break;
17237                                           case 3: 
17238                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
17239                                                     /* page at 16 */ == 1) 
17240                                               goto MATCH_label_c64;  /*opt-block+*/
17241                                             else { 
17242                                               MATCH_w_8_24 = 
17243                                                 getByte(3 + MATCH_p); 
17244                                               
17245                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
17246                                                       /* mod at 24 */) {
17247                                                   case 0: 
17248                                                     
17249                                                       switch((MATCH_w_8_24 & 0x7) 
17250                                                             /* r_m at 24 */) {
17251                                                         case 0: case 1: 
17252                                                         case 2: case 3: 
17253                                                         case 6: case 7: 
17254                                                           goto MATCH_label_c85; 
17255                                                           
17256                                                           break;
17257                                                         case 4: 
17258                                                           MATCH_w_8_32 = 
17259                                                             getByte(4 + 
17260                                                                   MATCH_p); 
17261                                                           if ((MATCH_w_8_32 & 0x7) 
17262                                                                   /* base at 32 */ == 5 && 
17263                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
17264                                                                   /* index at 32 */ && 
17265                                                             (MATCH_w_8_32 >> 3 & 0x7) 
17266                                                                   /* index at 32 */ < 8)) 
17267                                                             goto MATCH_label_c87;  /*opt-block+*/
17268                                                           else 
17269                                                             goto MATCH_label_c86;  /*opt-block+*/
17270                                                           
17271                                                           break;
17272                                                         case 5: 
17273                                                           goto MATCH_label_c88; 
17274                                                           
17275                                                           break;
17276                                                         default: assert(0);
17277                                                       } /* (MATCH_w_8_24 & 0x7) 
17278                                                             -- r_m at 24 --*/ 
17279                                                     break;
17280                                                   case 1: 
17281                                                     MATCH_w_8_32 = 
17282                                                       getByte(4 + MATCH_p); 
17283                                                     if ((MATCH_w_8_24 & 0x7) 
17284                                                             /* r_m at 24 */ == 4 && 
17285                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
17286                                                             /* index at 32 */ && 
17287                                                       (MATCH_w_8_32 >> 3 & 0x7) 
17288                                                             /* index at 32 */ < 8)) { 
17289                                                       unsigned Eaddr = 
17290                                                         3 + 
17291                                                         addressToPC(MATCH_p);
17292                                                       unsigned reg = 
17293                                                         (MATCH_w_8_24 >> 3 & 0x7) 
17294                                                               /* reg_opcode at 24 */;
17295                                                       nextPC = 6 + MATCH_p; 
17296                                                       
17297 #line 1049 "frontend/machine/pentium/decoder.m"
17298                                                       
17299 
17300                                                             stmts = instantiate(pc,  "LSLow", DIS_REG16, DIS_EADDR16);
17301 
17302                                                       
17303 
17304                                                       
17305                                                       
17306                                                       
17307                                                     } /*opt-block*//*opt-block+*/
17308                                                     else 
17309                                                       goto MATCH_label_c86;  /*opt-block+*/
17310                                                     
17311                                                     break;
17312                                                   case 2: 
17313                                                     MATCH_w_8_32 = 
17314                                                       getByte(4 + MATCH_p); 
17315                                                     if ((MATCH_w_8_24 & 0x7) 
17316                                                             /* r_m at 24 */ == 4 && 
17317                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
17318                                                             /* index at 32 */ && 
17319                                                       (MATCH_w_8_32 >> 3 & 0x7) 
17320                                                             /* index at 32 */ < 8)) 
17321                                                       goto MATCH_label_c87;  /*opt-block+*/
17322                                                     else 
17323                                                       goto MATCH_label_c88;  /*opt-block+*/
17324                                                     
17325                                                     break;
17326                                                   case 3: 
17327                                                     goto MATCH_label_c85; 
17328                                                     
17329                                                     break;
17330                                                   default: assert(0);
17331                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
17332                                                       -- mod at 24 --*/ 
17333                                               
17334                                             } /*opt-block*/
17335                                             break;
17336                                           default: assert(0);
17337                                         } /* (MATCH_w_8_16 & 0x7) 
17338                                               -- col at 16 --*/ 
17339                                       break;
17340                                     case 1: case 2: case 3: case 4: case 5: 
17341                                     case 6: case 7: case 9: case 13: case 14: 
17342                                     case 15: 
17343                                       goto MATCH_label_c64; break;
17344                                     case 8: 
17345                                       if ((MATCH_w_8_16 >> 3 & 0x1) 
17346                                               /* page at 16 */ == 1) 
17347                                         
17348                                           switch((MATCH_w_8_16 & 0x7) 
17349                                                 /* col at 16 */) {
17350                                             case 0: 
17351                                               MATCH_w_16_24 = 
17352                                                 getWord(3 + MATCH_p); 
17353                                               { 
17354                                                 unsigned relocd = 
17355                                                   5 + 
17356                                                   sign_extend((MATCH_w_16_24 & 0xffff) 
17357                                                                     /* i16 at 24 */, 
17358                                                               16) + 
17359                                                   addressToPC(MATCH_p);
17360                                                 nextPC = 5 + MATCH_p; 
17361                                                 
17362 #line 210 "frontend/machine/pentium/decoder.m"
17363                                                 
17364 
17365                                                         COND_JUMP("Jv.Sow", 4, relocd, BRANCH_JMI)
17366 
17367                                                 
17368                                                 
17369                                                 
17370                                               }
17371                                               
17372                                               break;
17373                                             case 1: 
17374                                               MATCH_w_16_24 = 
17375                                                 getWord(3 + MATCH_p); 
17376                                               { 
17377                                                 unsigned relocd = 
17378                                                   5 + 
17379                                                   sign_extend((MATCH_w_16_24 & 0xffff) 
17380                                                                     /* i16 at 24 */, 
17381                                                               16) + 
17382                                                   addressToPC(MATCH_p);
17383                                                 nextPC = 5 + MATCH_p; 
17384                                                 
17385 #line 208 "frontend/machine/pentium/decoder.m"
17386                                                 
17387 
17388                                                         COND_JUMP("Jv.NSow", 4, relocd, BRANCH_JPOS)
17389 
17390                                                 
17391                                                 
17392                                                 
17393                                               }
17394                                               
17395                                               break;
17396                                             case 2: 
17397                                               MATCH_w_16_24 = 
17398                                                 getWord(3 + MATCH_p); 
17399                                               { 
17400                                                 unsigned relocd = 
17401                                                   5 + 
17402                                                   sign_extend((MATCH_w_16_24 & 0xffff) 
17403                                                                     /* i16 at 24 */, 
17404                                                               16) + 
17405                                                   addressToPC(MATCH_p);
17406                                                 nextPC = 5 + MATCH_p; 
17407                                                 
17408 #line 206 "frontend/machine/pentium/decoder.m"
17409                                                 
17410 
17411                                                         COND_JUMP("Jv.Pow", 4, relocd, BRANCH_JPAR)
17412 
17413                                                 
17414                                                 
17415                                                 
17416                                               }
17417                                               
17418                                               break;
17419                                             case 3: 
17420                                               MATCH_w_16_24 = 
17421                                                 getWord(3 + MATCH_p); 
17422                                               { 
17423                                                 unsigned relocd = 
17424                                                   5 + 
17425                                                   sign_extend((MATCH_w_16_24 & 0xffff) 
17426                                                                     /* i16 at 24 */, 
17427                                                               16) + 
17428                                                   addressToPC(MATCH_p);
17429                                                 nextPC = 5 + MATCH_p; 
17430                                                 
17431 #line 204 "frontend/machine/pentium/decoder.m"
17432                                                 
17433 
17434                                                         COND_JUMP("Jv.NPow", 4, relocd, (BRANCH_TYPE)0)
17435 
17436                                                 
17437                                                 
17438                                                 
17439                                               }
17440                                               
17441                                               break;
17442                                             case 4: 
17443                                               MATCH_w_16_24 = 
17444                                                 getWord(3 + MATCH_p); 
17445                                               { 
17446                                                 unsigned relocd = 
17447                                                   5 + 
17448                                                   sign_extend((MATCH_w_16_24 & 0xffff) 
17449                                                                     /* i16 at 24 */, 
17450                                                               16) + 
17451                                                   addressToPC(MATCH_p);
17452                                                 nextPC = 5 + MATCH_p; 
17453                                                 
17454 #line 202 "frontend/machine/pentium/decoder.m"
17455                                                 
17456 
17457                                                         COND_JUMP("Jv.Low", 4, relocd, BRANCH_JSL)
17458 
17459                                                 
17460                                                 
17461                                                 
17462                                               }
17463                                               
17464                                               break;
17465                                             case 5: 
17466                                               MATCH_w_16_24 = 
17467                                                 getWord(3 + MATCH_p); 
17468                                               { 
17469                                                 unsigned relocd = 
17470                                                   5 + 
17471                                                   sign_extend((MATCH_w_16_24 & 0xffff) 
17472                                                                     /* i16 at 24 */, 
17473                                                               16) + 
17474                                                   addressToPC(MATCH_p);
17475                                                 nextPC = 5 + MATCH_p; 
17476                                                 
17477 #line 200 "frontend/machine/pentium/decoder.m"
17478                                                 
17479 
17480                                                         COND_JUMP("Jv.NLow", 4, relocd, BRANCH_JSGE)
17481 
17482                                                 
17483                                                 
17484                                                 
17485                                               }
17486                                               
17487                                               break;
17488                                             case 6: 
17489                                               MATCH_w_16_24 = 
17490                                                 getWord(3 + MATCH_p); 
17491                                               { 
17492                                                 unsigned relocd = 
17493                                                   5 + 
17494                                                   sign_extend((MATCH_w_16_24 & 0xffff) 
17495                                                                     /* i16 at 24 */, 
17496                                                               16) + 
17497                                                   addressToPC(MATCH_p);
17498                                                 nextPC = 5 + MATCH_p; 
17499                                                 
17500 #line 198 "frontend/machine/pentium/decoder.m"
17501                                                 
17502 
17503                                                         COND_JUMP("Jv.LEow", 4, relocd, BRANCH_JSLE)
17504 
17505                                                 
17506                                                 
17507                                                 
17508                                               }
17509                                               
17510                                               break;
17511                                             case 7: 
17512                                               MATCH_w_16_24 = 
17513                                                 getWord(3 + MATCH_p); 
17514                                               { 
17515                                                 unsigned relocd = 
17516                                                   5 + 
17517                                                   sign_extend((MATCH_w_16_24 & 0xffff) 
17518                                                                     /* i16 at 24 */, 
17519                                                               16) + 
17520                                                   addressToPC(MATCH_p);
17521                                                 nextPC = 5 + MATCH_p; 
17522                                                 
17523 #line 196 "frontend/machine/pentium/decoder.m"
17524                                                 
17525 
17526                                                         COND_JUMP("Jv.NLEow", 4, relocd, BRANCH_JSG)
17527 
17528                                                 
17529                                                 
17530                                                 
17531                                               }
17532                                               
17533                                               break;
17534                                             default: assert(0);
17535                                           } /* (MATCH_w_8_16 & 0x7) 
17536                                                 -- col at 16 --*/  
17537                                       else 
17538                                         
17539                                           switch((MATCH_w_8_16 & 0x7) 
17540                                                 /* col at 16 */) {
17541                                             case 0: 
17542                                               MATCH_w_16_24 = 
17543                                                 getWord(3 + MATCH_p); 
17544                                               { 
17545                                                 unsigned relocd = 
17546                                                   5 + 
17547                                                   sign_extend((MATCH_w_16_24 & 0xffff) 
17548                                                                     /* i16 at 24 */, 
17549                                                               16) + 
17550                                                   addressToPC(MATCH_p);
17551                                                 nextPC = 5 + MATCH_p; 
17552                                                 
17553 #line 227 "frontend/machine/pentium/decoder.m"
17554                                                 
17555 
17556                                                         COND_JUMP("Jv.Oow", 4, relocd, (BRANCH_TYPE)0)
17557 
17558                                                 
17559 
17560                                                     /*
17561 
17562                                                      * Conditional branches, 32 bit offset: 0F 8X XX XX XX XX
17563 
17564                                                      */
17565 
17566                                                 
17567                                                 
17568                                                 
17569                                               }
17570                                               
17571                                               break;
17572                                             case 1: 
17573                                               MATCH_w_16_24 = 
17574                                                 getWord(3 + MATCH_p); 
17575                                               { 
17576                                                 unsigned relocd = 
17577                                                   5 + 
17578                                                   sign_extend((MATCH_w_16_24 & 0xffff) 
17579                                                                     /* i16 at 24 */, 
17580                                                               16) + 
17581                                                   addressToPC(MATCH_p);
17582                                                 nextPC = 5 + MATCH_p; 
17583                                                 
17584 #line 224 "frontend/machine/pentium/decoder.m"
17585                                                 
17586 
17587                                                         COND_JUMP("Jv.NOow", 4, relocd, (BRANCH_TYPE)0)
17588 
17589                                                 
17590                                                 
17591                                                 
17592                                               }
17593                                               
17594                                               break;
17595                                             case 2: 
17596                                               MATCH_w_16_24 = 
17597                                                 getWord(3 + MATCH_p); 
17598                                               { 
17599                                                 unsigned relocd = 
17600                                                   5 + 
17601                                                   sign_extend((MATCH_w_16_24 & 0xffff) 
17602                                                                     /* i16 at 24 */, 
17603                                                               16) + 
17604                                                   addressToPC(MATCH_p);
17605                                                 nextPC = 5 + MATCH_p; 
17606                                                 
17607 #line 222 "frontend/machine/pentium/decoder.m"
17608                                                 
17609 
17610                                                         COND_JUMP("Jv.Bow", 4, relocd, BRANCH_JUL)
17611 
17612                                                 
17613                                                 
17614                                                 
17615                                               }
17616                                               
17617                                               break;
17618                                             case 3: 
17619                                               MATCH_w_16_24 = 
17620                                                 getWord(3 + MATCH_p); 
17621                                               { 
17622                                                 unsigned relocd = 
17623                                                   5 + 
17624                                                   sign_extend((MATCH_w_16_24 & 0xffff) 
17625                                                                     /* i16 at 24 */, 
17626                                                               16) + 
17627                                                   addressToPC(MATCH_p);
17628                                                 nextPC = 5 + MATCH_p; 
17629                                                 
17630 #line 220 "frontend/machine/pentium/decoder.m"
17631                                                 
17632 
17633                                                         COND_JUMP("Jv.NBow", 4, relocd, BRANCH_JUGE)
17634 
17635                                                 
17636                                                 
17637                                                 
17638                                               }
17639                                               
17640                                               break;
17641                                             case 4: 
17642                                               MATCH_w_16_24 = 
17643                                                 getWord(3 + MATCH_p); 
17644                                               { 
17645                                                 unsigned relocd = 
17646                                                   5 + 
17647                                                   sign_extend((MATCH_w_16_24 & 0xffff) 
17648                                                                     /* i16 at 24 */, 
17649                                                               16) + 
17650                                                   addressToPC(MATCH_p);
17651                                                 nextPC = 5 + MATCH_p; 
17652                                                 
17653 #line 218 "frontend/machine/pentium/decoder.m"
17654                                                 
17655 
17656                                                         COND_JUMP("Jv.Zow", 4, relocd, BRANCH_JE)
17657 
17658                                                 
17659                                                 
17660                                                 
17661                                               }
17662                                               
17663                                               break;
17664                                             case 5: 
17665                                               MATCH_w_16_24 = 
17666                                                 getWord(3 + MATCH_p); 
17667                                               { 
17668                                                 unsigned relocd = 
17669                                                   5 + 
17670                                                   sign_extend((MATCH_w_16_24 & 0xffff) 
17671                                                                     /* i16 at 24 */, 
17672                                                               16) + 
17673                                                   addressToPC(MATCH_p);
17674                                                 nextPC = 5 + MATCH_p; 
17675                                                 
17676 #line 216 "frontend/machine/pentium/decoder.m"
17677                                                 
17678 
17679                                                         COND_JUMP("Jv.NZow", 4, relocd, BRANCH_JNE)
17680 
17681                                                 
17682                                                 
17683                                                 
17684                                               }
17685                                               
17686                                               break;
17687                                             case 6: 
17688                                               MATCH_w_16_24 = 
17689                                                 getWord(3 + MATCH_p); 
17690                                               { 
17691                                                 unsigned relocd = 
17692                                                   5 + 
17693                                                   sign_extend((MATCH_w_16_24 & 0xffff) 
17694                                                                     /* i16 at 24 */, 
17695                                                               16) + 
17696                                                   addressToPC(MATCH_p);
17697                                                 nextPC = 5 + MATCH_p; 
17698                                                 
17699 #line 214 "frontend/machine/pentium/decoder.m"
17700                                                 
17701 
17702                                                         COND_JUMP("Jv.BEow", 4, relocd, BRANCH_JULE)
17703 
17704                                                 
17705                                                 
17706                                                 
17707                                               }
17708                                               
17709                                               break;
17710                                             case 7: 
17711                                               MATCH_w_16_24 = 
17712                                                 getWord(3 + MATCH_p); 
17713                                               { 
17714                                                 unsigned relocd = 
17715                                                   5 + 
17716                                                   sign_extend((MATCH_w_16_24 & 0xffff) 
17717                                                                     /* i16 at 24 */, 
17718                                                               16) + 
17719                                                   addressToPC(MATCH_p);
17720                                                 nextPC = 5 + MATCH_p; 
17721                                                 
17722 #line 212 "frontend/machine/pentium/decoder.m"
17723                                                 
17724 
17725                                                         COND_JUMP("Jv.NBEow", 4, relocd, BRANCH_JUG)
17726 
17727                                                 
17728                                                 
17729                                                 
17730                                               }
17731                                               
17732                                               break;
17733                                             default: assert(0);
17734                                           } /* (MATCH_w_8_16 & 0x7) 
17735                                                 -- col at 16 --*/  
17736                                       break;
17737                                     case 10: 
17738                                       
17739                                         switch((MATCH_w_8_16 & 0x7) 
17740                                               /* col at 16 */) {
17741                                           case 0: case 1: case 2: case 6: 
17742                                             goto MATCH_label_c64; break;
17743                                           case 3: 
17744                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
17745                                                     /* page at 16 */ == 1) { 
17746                                               MATCH_w_8_24 = 
17747                                                 getByte(3 + MATCH_p); 
17748                                               
17749                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
17750                                                       /* mod at 24 */) {
17751                                                   case 0: 
17752                                                     
17753                                                       switch((MATCH_w_8_24 & 0x7) 
17754                                                             /* r_m at 24 */) {
17755                                                         case 0: case 1: 
17756                                                         case 2: case 3: 
17757                                                         case 6: case 7: 
17758                                                           goto MATCH_label_c93; 
17759                                                           
17760                                                           break;
17761                                                         case 4: 
17762                                                           MATCH_w_8_32 = 
17763                                                             getByte(4 + 
17764                                                                   MATCH_p); 
17765                                                           if ((MATCH_w_8_32 & 0x7) 
17766                                                                   /* base at 32 */ == 5 && 
17767                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
17768                                                                   /* index at 32 */ && 
17769                                                             (MATCH_w_8_32 >> 3 & 0x7) 
17770                                                                   /* index at 32 */ < 8)) 
17771                                                             goto MATCH_label_c95;  /*opt-block+*/
17772                                                           else 
17773                                                             goto MATCH_label_c94;  /*opt-block+*/
17774                                                           
17775                                                           break;
17776                                                         case 5: 
17777                                                           goto MATCH_label_c96; 
17778                                                           
17779                                                           break;
17780                                                         default: assert(0);
17781                                                       } /* (MATCH_w_8_24 & 0x7) 
17782                                                             -- r_m at 24 --*/ 
17783                                                     break;
17784                                                   case 1: 
17785                                                     MATCH_w_8_32 = 
17786                                                       getByte(4 + MATCH_p); 
17787                                                     if ((MATCH_w_8_24 & 0x7) 
17788                                                             /* r_m at 24 */ == 4 && 
17789                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
17790                                                             /* index at 32 */ && 
17791                                                       (MATCH_w_8_32 >> 3 & 0x7) 
17792                                                             /* index at 32 */ < 8)) { 
17793                                                       unsigned Eaddr = 
17794                                                         3 + 
17795                                                         addressToPC(MATCH_p);
17796                                                       unsigned reg = 
17797                                                         (MATCH_w_8_24 >> 3 & 0x7) 
17798                                                               /* reg_opcode at 24 */;
17799                                                       nextPC = 6 + MATCH_p; 
17800                                                       
17801 #line 1319 "frontend/machine/pentium/decoder.m"
17802                                                       
17803 
17804                                                             stmts = instantiate(pc,  "BTSow", DIS_EADDR16, DIS_REG16);
17805 
17806                                                       
17807 
17808                                                       
17809                                                       
17810                                                       
17811                                                     } /*opt-block*//*opt-block+*/
17812                                                     else 
17813                                                       goto MATCH_label_c94;  /*opt-block+*/
17814                                                     
17815                                                     break;
17816                                                   case 2: 
17817                                                     MATCH_w_8_32 = 
17818                                                       getByte(4 + MATCH_p); 
17819                                                     if ((MATCH_w_8_24 & 0x7) 
17820                                                             /* r_m at 24 */ == 4 && 
17821                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
17822                                                             /* index at 32 */ && 
17823                                                       (MATCH_w_8_32 >> 3 & 0x7) 
17824                                                             /* index at 32 */ < 8)) 
17825                                                       goto MATCH_label_c95;  /*opt-block+*/
17826                                                     else 
17827                                                       goto MATCH_label_c96;  /*opt-block+*/
17828                                                     
17829                                                     break;
17830                                                   case 3: 
17831                                                     goto MATCH_label_c93; 
17832                                                     
17833                                                     break;
17834                                                   default: assert(0);
17835                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
17836                                                       -- mod at 24 --*/ 
17837                                               
17838                                             } /*opt-block*/
17839                                             else { 
17840                                               MATCH_w_8_24 = 
17841                                                 getByte(3 + MATCH_p); 
17842                                               
17843                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
17844                                                       /* mod at 24 */) {
17845                                                   case 0: 
17846                                                     
17847                                                       switch((MATCH_w_8_24 & 0x7) 
17848                                                             /* r_m at 24 */) {
17849                                                         case 0: case 1: 
17850                                                         case 2: case 3: 
17851                                                         case 6: case 7: 
17852                                                           goto MATCH_label_c89; 
17853                                                           
17854                                                           break;
17855                                                         case 4: 
17856                                                           MATCH_w_8_32 = 
17857                                                             getByte(4 + 
17858                                                                   MATCH_p); 
17859                                                           if ((MATCH_w_8_32 & 0x7) 
17860                                                                   /* base at 32 */ == 5 && 
17861                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
17862                                                                   /* index at 32 */ && 
17863                                                             (MATCH_w_8_32 >> 3 & 0x7) 
17864                                                                   /* index at 32 */ < 8)) 
17865                                                             goto MATCH_label_c91;  /*opt-block+*/
17866                                                           else 
17867                                                             goto MATCH_label_c90;  /*opt-block+*/
17868                                                           
17869                                                           break;
17870                                                         case 5: 
17871                                                           goto MATCH_label_c92; 
17872                                                           
17873                                                           break;
17874                                                         default: assert(0);
17875                                                       } /* (MATCH_w_8_24 & 0x7) 
17876                                                             -- r_m at 24 --*/ 
17877                                                     break;
17878                                                   case 1: 
17879                                                     MATCH_w_8_32 = 
17880                                                       getByte(4 + MATCH_p); 
17881                                                     if ((MATCH_w_8_24 & 0x7) 
17882                                                             /* r_m at 24 */ == 4 && 
17883                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
17884                                                             /* index at 32 */ && 
17885                                                       (MATCH_w_8_32 >> 3 & 0x7) 
17886                                                             /* index at 32 */ < 8)) { 
17887                                                       unsigned Eaddr = 
17888                                                         3 + 
17889                                                         addressToPC(MATCH_p);
17890                                                       unsigned reg = 
17891                                                         (MATCH_w_8_24 >> 3 & 0x7) 
17892                                                               /* reg_opcode at 24 */;
17893                                                       nextPC = 6 + MATCH_p; 
17894                                                       
17895 #line 1355 "frontend/machine/pentium/decoder.m"
17896                                                       
17897 
17898                                                             stmts = instantiate(pc,  "BTow", DIS_EADDR16, DIS_REG16);
17899 
17900                                                       
17901 
17902                                                       
17903                                                       
17904                                                       
17905                                                     } /*opt-block*//*opt-block+*/
17906                                                     else 
17907                                                       goto MATCH_label_c90;  /*opt-block+*/
17908                                                     
17909                                                     break;
17910                                                   case 2: 
17911                                                     MATCH_w_8_32 = 
17912                                                       getByte(4 + MATCH_p); 
17913                                                     if ((MATCH_w_8_24 & 0x7) 
17914                                                             /* r_m at 24 */ == 4 && 
17915                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
17916                                                             /* index at 32 */ && 
17917                                                       (MATCH_w_8_32 >> 3 & 0x7) 
17918                                                             /* index at 32 */ < 8)) 
17919                                                       goto MATCH_label_c91;  /*opt-block+*/
17920                                                     else 
17921                                                       goto MATCH_label_c92;  /*opt-block+*/
17922                                                     
17923                                                     break;
17924                                                   case 3: 
17925                                                     goto MATCH_label_c89; 
17926                                                     
17927                                                     break;
17928                                                   default: assert(0);
17929                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
17930                                                       -- mod at 24 --*/ 
17931                                               
17932                                             } /*opt-block*/
17933                                             break;
17934                                           case 4: 
17935                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
17936                                                     /* page at 16 */ == 1) { 
17937                                               MATCH_w_8_24 = 
17938                                                 getByte(3 + MATCH_p); 
17939                                               
17940                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
17941                                                       /* mod at 24 */) {
17942                                                   case 0: 
17943                                                     
17944                                                       switch((MATCH_w_8_24 & 0x7) 
17945                                                             /* r_m at 24 */) {
17946                                                         case 0: case 1: 
17947                                                         case 2: case 3: 
17948                                                         case 6: case 7: 
17949                                                           MATCH_w_8_32 = 
17950                                                             getByte(4 + 
17951                                                                   MATCH_p); 
17952                                                           goto MATCH_label_c101; 
17953                                                           
17954                                                           break;
17955                                                         case 4: 
17956                                                           MATCH_w_8_32 = 
17957                                                             getByte(4 + 
17958                                                                   MATCH_p); 
17959                                                           if ((MATCH_w_8_32 & 0x7) 
17960                                                                   /* base at 32 */ == 5 && 
17961                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
17962                                                                   /* index at 32 */ && 
17963                                                             (MATCH_w_8_32 >> 3 & 0x7) 
17964                                                                   /* index at 32 */ < 8)) { 
17965                                                             MATCH_w_8_72 = 
17966                                                               getByte(9 + 
17967                                                                     MATCH_p); 
17968                                                             goto MATCH_label_c103; 
17969                                                             
17970                                                           } /*opt-block*/
17971                                                           else { 
17972                                                             MATCH_w_8_40 = 
17973                                                               getByte(5 + 
17974                                                                     MATCH_p); 
17975                                                             goto MATCH_label_c102; 
17976                                                             
17977                                                           } /*opt-block*/
17978                                                           
17979                                                           break;
17980                                                         case 5: 
17981                                                           MATCH_w_8_64 = 
17982                                                             getByte(8 + 
17983                                                                   MATCH_p); 
17984                                                           goto MATCH_label_c104; 
17985                                                           
17986                                                           break;
17987                                                         default: assert(0);
17988                                                       } /* (MATCH_w_8_24 & 0x7) 
17989                                                             -- r_m at 24 --*/ 
17990                                                     break;
17991                                                   case 1: 
17992                                                     MATCH_w_8_32 = 
17993                                                       getByte(4 + MATCH_p); 
17994                                                     if ((MATCH_w_8_24 & 0x7) 
17995                                                             /* r_m at 24 */ == 4 && 
17996                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
17997                                                             /* index at 32 */ && 
17998                                                       (MATCH_w_8_32 >> 3 & 0x7) 
17999                                                             /* index at 32 */ < 8)) { 
18000                                                       MATCH_w_8_48 = 
18001                                                         getByte(6 + MATCH_p); 
18002                                                       { 
18003                                                         unsigned Eaddr = 
18004                                                           3 + 
18005                                                           addressToPC(MATCH_p);
18006                                                         unsigned count = 
18007                                                           (MATCH_w_8_48 & 0xff) 
18008                                                                 /* i8 at 48 */;
18009                                                         unsigned reg = 
18010                                                           (MATCH_w_8_24 >> 3 & 0x7) 
18011                                                                 /* reg_opcode at 24 */;
18012                                                         nextPC = 7 + MATCH_p; 
18013                                                         
18014 #line 453 "frontend/machine/pentium/decoder.m"
18015                                                         
18016 
18017                                                                 stmts = instantiate(pc,  "SHRD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
18018 
18019                                                         
18020 
18021                                                         
18022                                                         
18023                                                         
18024                                                       }
18025                                                       
18026                                                     } /*opt-block*/
18027                                                     else { 
18028                                                       MATCH_w_8_40 = 
18029                                                         getByte(5 + MATCH_p); 
18030                                                       goto MATCH_label_c102; 
18031                                                       
18032                                                     } /*opt-block*/
18033                                                     
18034                                                     break;
18035                                                   case 2: 
18036                                                     MATCH_w_8_32 = 
18037                                                       getByte(4 + MATCH_p); 
18038                                                     if ((MATCH_w_8_24 & 0x7) 
18039                                                             /* r_m at 24 */ == 4 && 
18040                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18041                                                             /* index at 32 */ && 
18042                                                       (MATCH_w_8_32 >> 3 & 0x7) 
18043                                                             /* index at 32 */ < 8)) { 
18044                                                       MATCH_w_8_72 = 
18045                                                         getByte(9 + MATCH_p); 
18046                                                       goto MATCH_label_c103; 
18047                                                       
18048                                                     } /*opt-block*/
18049                                                     else { 
18050                                                       MATCH_w_8_64 = 
18051                                                         getByte(8 + MATCH_p); 
18052                                                       goto MATCH_label_c104; 
18053                                                       
18054                                                     } /*opt-block*/
18055                                                     
18056                                                     break;
18057                                                   case 3: 
18058                                                     MATCH_w_8_32 = 
18059                                                       getByte(4 + MATCH_p); 
18060                                                     goto MATCH_label_c101; 
18061                                                     
18062                                                     break;
18063                                                   default: assert(0);
18064                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
18065                                                       -- mod at 24 --*/ 
18066                                               
18067                                             } /*opt-block*/
18068                                             else { 
18069                                               MATCH_w_8_24 = 
18070                                                 getByte(3 + MATCH_p); 
18071                                               
18072                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
18073                                                       /* mod at 24 */) {
18074                                                   case 0: 
18075                                                     
18076                                                       switch((MATCH_w_8_24 & 0x7) 
18077                                                             /* r_m at 24 */) {
18078                                                         case 0: case 1: 
18079                                                         case 2: case 3: 
18080                                                         case 6: case 7: 
18081                                                           MATCH_w_8_32 = 
18082                                                             getByte(4 + 
18083                                                                   MATCH_p); 
18084                                                           goto MATCH_label_c97; 
18085                                                           
18086                                                           break;
18087                                                         case 4: 
18088                                                           MATCH_w_8_32 = 
18089                                                             getByte(4 + 
18090                                                                   MATCH_p); 
18091                                                           if ((MATCH_w_8_32 & 0x7) 
18092                                                                   /* base at 32 */ == 5 && 
18093                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18094                                                                   /* index at 32 */ && 
18095                                                             (MATCH_w_8_32 >> 3 & 0x7) 
18096                                                                   /* index at 32 */ < 8)) { 
18097                                                             MATCH_w_8_72 = 
18098                                                               getByte(9 + 
18099                                                                     MATCH_p); 
18100                                                             goto MATCH_label_c99; 
18101                                                             
18102                                                           } /*opt-block*/
18103                                                           else { 
18104                                                             MATCH_w_8_40 = 
18105                                                               getByte(5 + 
18106                                                                     MATCH_p); 
18107                                                             goto MATCH_label_c98; 
18108                                                             
18109                                                           } /*opt-block*/
18110                                                           
18111                                                           break;
18112                                                         case 5: 
18113                                                           MATCH_w_8_64 = 
18114                                                             getByte(8 + 
18115                                                                   MATCH_p); 
18116                                                           goto MATCH_label_c100; 
18117                                                           
18118                                                           break;
18119                                                         default: assert(0);
18120                                                       } /* (MATCH_w_8_24 & 0x7) 
18121                                                             -- r_m at 24 --*/ 
18122                                                     break;
18123                                                   case 1: 
18124                                                     MATCH_w_8_32 = 
18125                                                       getByte(4 + MATCH_p); 
18126                                                     if ((MATCH_w_8_24 & 0x7) 
18127                                                             /* r_m at 24 */ == 4 && 
18128                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18129                                                             /* index at 32 */ && 
18130                                                       (MATCH_w_8_32 >> 3 & 0x7) 
18131                                                             /* index at 32 */ < 8)) { 
18132                                                       MATCH_w_8_48 = 
18133                                                         getByte(6 + MATCH_p); 
18134                                                       { 
18135                                                         unsigned Eaddr = 
18136                                                           3 + 
18137                                                           addressToPC(MATCH_p);
18138                                                         unsigned count = 
18139                                                           (MATCH_w_8_48 & 0xff) 
18140                                                                 /* i8 at 48 */;
18141                                                         unsigned reg = 
18142                                                           (MATCH_w_8_24 >> 3 & 0x7) 
18143                                                                 /* reg_opcode at 24 */;
18144                                                         nextPC = 7 + MATCH_p; 
18145                                                         
18146 #line 447 "frontend/machine/pentium/decoder.m"
18147                                                         
18148 
18149                                                                 stmts = instantiate(pc,  "SHLD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
18150 
18151                                                         
18152 
18153                                                         
18154                                                         
18155                                                         
18156                                                       }
18157                                                       
18158                                                     } /*opt-block*/
18159                                                     else { 
18160                                                       MATCH_w_8_40 = 
18161                                                         getByte(5 + MATCH_p); 
18162                                                       goto MATCH_label_c98; 
18163                                                       
18164                                                     } /*opt-block*/
18165                                                     
18166                                                     break;
18167                                                   case 2: 
18168                                                     MATCH_w_8_32 = 
18169                                                       getByte(4 + MATCH_p); 
18170                                                     if ((MATCH_w_8_24 & 0x7) 
18171                                                             /* r_m at 24 */ == 4 && 
18172                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18173                                                             /* index at 32 */ && 
18174                                                       (MATCH_w_8_32 >> 3 & 0x7) 
18175                                                             /* index at 32 */ < 8)) { 
18176                                                       MATCH_w_8_72 = 
18177                                                         getByte(9 + MATCH_p); 
18178                                                       goto MATCH_label_c99; 
18179                                                       
18180                                                     } /*opt-block*/
18181                                                     else { 
18182                                                       MATCH_w_8_64 = 
18183                                                         getByte(8 + MATCH_p); 
18184                                                       goto MATCH_label_c100; 
18185                                                       
18186                                                     } /*opt-block*/
18187                                                     
18188                                                     break;
18189                                                   case 3: 
18190                                                     MATCH_w_8_32 = 
18191                                                       getByte(4 + MATCH_p); 
18192                                                     goto MATCH_label_c97; 
18193                                                     
18194                                                     break;
18195                                                   default: assert(0);
18196                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
18197                                                       -- mod at 24 --*/ 
18198                                               
18199                                             } /*opt-block*/
18200                                             break;
18201                                           case 5: 
18202                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
18203                                                     /* page at 16 */ == 1) { 
18204                                               MATCH_w_8_24 = 
18205                                                 getByte(3 + MATCH_p); 
18206                                               
18207                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
18208                                                       /* mod at 24 */) {
18209                                                   case 0: 
18210                                                     
18211                                                       switch((MATCH_w_8_24 & 0x7) 
18212                                                             /* r_m at 24 */) {
18213                                                         case 0: case 1: 
18214                                                         case 2: case 3: 
18215                                                         case 6: case 7: 
18216                                                           goto MATCH_label_c109; 
18217                                                           
18218                                                           break;
18219                                                         case 4: 
18220                                                           MATCH_w_8_32 = 
18221                                                             getByte(4 + 
18222                                                                   MATCH_p); 
18223                                                           if ((MATCH_w_8_32 & 0x7) 
18224                                                                   /* base at 32 */ == 5 && 
18225                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18226                                                                   /* index at 32 */ && 
18227                                                             (MATCH_w_8_32 >> 3 & 0x7) 
18228                                                                   /* index at 32 */ < 8)) 
18229                                                             goto MATCH_label_c111;  /*opt-block+*/
18230                                                           else 
18231                                                             goto MATCH_label_c110;  /*opt-block+*/
18232                                                           
18233                                                           break;
18234                                                         case 5: 
18235                                                           goto MATCH_label_c112; 
18236                                                           
18237                                                           break;
18238                                                         default: assert(0);
18239                                                       } /* (MATCH_w_8_24 & 0x7) 
18240                                                             -- r_m at 24 --*/ 
18241                                                     break;
18242                                                   case 1: 
18243                                                     MATCH_w_8_32 = 
18244                                                       getByte(4 + MATCH_p); 
18245                                                     if ((MATCH_w_8_24 & 0x7) 
18246                                                             /* r_m at 24 */ == 4 && 
18247                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18248                                                             /* index at 32 */ && 
18249                                                       (MATCH_w_8_32 >> 3 & 0x7) 
18250                                                             /* index at 32 */ < 8)) { 
18251                                                       unsigned Eaddr = 
18252                                                         3 + 
18253                                                         addressToPC(MATCH_p);
18254                                                       unsigned reg = 
18255                                                         (MATCH_w_8_24 >> 3 & 0x7) 
18256                                                               /* reg_opcode at 24 */;
18257                                                       nextPC = 6 + MATCH_p; 
18258                                                       
18259 #line 441 "frontend/machine/pentium/decoder.m"
18260                                                       
18261 
18262                                                             stmts = instantiate(pc,  "SHRD.CLow", DIS_EADDR16, DIS_REG16);
18263 
18264                                                       
18265 
18266                                                       
18267                                                       
18268                                                       
18269                                                     } /*opt-block*//*opt-block+*/
18270                                                     else 
18271                                                       goto MATCH_label_c110;  /*opt-block+*/
18272                                                     
18273                                                     break;
18274                                                   case 2: 
18275                                                     MATCH_w_8_32 = 
18276                                                       getByte(4 + MATCH_p); 
18277                                                     if ((MATCH_w_8_24 & 0x7) 
18278                                                             /* r_m at 24 */ == 4 && 
18279                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18280                                                             /* index at 32 */ && 
18281                                                       (MATCH_w_8_32 >> 3 & 0x7) 
18282                                                             /* index at 32 */ < 8)) 
18283                                                       goto MATCH_label_c111;  /*opt-block+*/
18284                                                     else 
18285                                                       goto MATCH_label_c112;  /*opt-block+*/
18286                                                     
18287                                                     break;
18288                                                   case 3: 
18289                                                     goto MATCH_label_c109; 
18290                                                     
18291                                                     break;
18292                                                   default: assert(0);
18293                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
18294                                                       -- mod at 24 --*/ 
18295                                               
18296                                             } /*opt-block*/
18297                                             else { 
18298                                               MATCH_w_8_24 = 
18299                                                 getByte(3 + MATCH_p); 
18300                                               
18301                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
18302                                                       /* mod at 24 */) {
18303                                                   case 0: 
18304                                                     
18305                                                       switch((MATCH_w_8_24 & 0x7) 
18306                                                             /* r_m at 24 */) {
18307                                                         case 0: case 1: 
18308                                                         case 2: case 3: 
18309                                                         case 6: case 7: 
18310                                                           goto MATCH_label_c105; 
18311                                                           
18312                                                           break;
18313                                                         case 4: 
18314                                                           MATCH_w_8_32 = 
18315                                                             getByte(4 + 
18316                                                                   MATCH_p); 
18317                                                           if ((MATCH_w_8_32 & 0x7) 
18318                                                                   /* base at 32 */ == 5 && 
18319                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18320                                                                   /* index at 32 */ && 
18321                                                             (MATCH_w_8_32 >> 3 & 0x7) 
18322                                                                   /* index at 32 */ < 8)) 
18323                                                             goto MATCH_label_c107;  /*opt-block+*/
18324                                                           else 
18325                                                             goto MATCH_label_c106;  /*opt-block+*/
18326                                                           
18327                                                           break;
18328                                                         case 5: 
18329                                                           goto MATCH_label_c108; 
18330                                                           
18331                                                           break;
18332                                                         default: assert(0);
18333                                                       } /* (MATCH_w_8_24 & 0x7) 
18334                                                             -- r_m at 24 --*/ 
18335                                                     break;
18336                                                   case 1: 
18337                                                     MATCH_w_8_32 = 
18338                                                       getByte(4 + MATCH_p); 
18339                                                     if ((MATCH_w_8_24 & 0x7) 
18340                                                             /* r_m at 24 */ == 4 && 
18341                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18342                                                             /* index at 32 */ && 
18343                                                       (MATCH_w_8_32 >> 3 & 0x7) 
18344                                                             /* index at 32 */ < 8)) { 
18345                                                       unsigned Eaddr = 
18346                                                         3 + 
18347                                                         addressToPC(MATCH_p);
18348                                                       unsigned reg = 
18349                                                         (MATCH_w_8_24 >> 3 & 0x7) 
18350                                                               /* reg_opcode at 24 */;
18351                                                       nextPC = 6 + MATCH_p; 
18352                                                       
18353 #line 435 "frontend/machine/pentium/decoder.m"
18354                                                       
18355 
18356                                                             stmts = instantiate(pc,  "SHLD.CLow", DIS_EADDR16, DIS_REG16);
18357 
18358                                                       
18359 
18360                                                       
18361                                                       
18362                                                       
18363                                                     } /*opt-block*//*opt-block+*/
18364                                                     else 
18365                                                       goto MATCH_label_c106;  /*opt-block+*/
18366                                                     
18367                                                     break;
18368                                                   case 2: 
18369                                                     MATCH_w_8_32 = 
18370                                                       getByte(4 + MATCH_p); 
18371                                                     if ((MATCH_w_8_24 & 0x7) 
18372                                                             /* r_m at 24 */ == 4 && 
18373                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18374                                                             /* index at 32 */ && 
18375                                                       (MATCH_w_8_32 >> 3 & 0x7) 
18376                                                             /* index at 32 */ < 8)) 
18377                                                       goto MATCH_label_c107;  /*opt-block+*/
18378                                                     else 
18379                                                       goto MATCH_label_c108;  /*opt-block+*/
18380                                                     
18381                                                     break;
18382                                                   case 3: 
18383                                                     goto MATCH_label_c105; 
18384                                                     
18385                                                     break;
18386                                                   default: assert(0);
18387                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
18388                                                       -- mod at 24 --*/ 
18389                                               
18390                                             } /*opt-block*/
18391                                             break;
18392                                           case 7: 
18393                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
18394                                                     /* page at 16 */ == 1) { 
18395                                               MATCH_w_8_24 = 
18396                                                 getByte(3 + MATCH_p); 
18397                                               
18398                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
18399                                                       /* mod at 24 */) {
18400                                                   case 0: 
18401                                                     
18402                                                       switch((MATCH_w_8_24 & 0x7) 
18403                                                             /* r_m at 24 */) {
18404                                                         case 0: case 1: 
18405                                                         case 2: case 3: 
18406                                                         case 6: case 7: 
18407                                                           goto MATCH_label_c113; 
18408                                                           
18409                                                           break;
18410                                                         case 4: 
18411                                                           MATCH_w_8_32 = 
18412                                                             getByte(4 + 
18413                                                                   MATCH_p); 
18414                                                           if ((MATCH_w_8_32 & 0x7) 
18415                                                                   /* base at 32 */ == 5 && 
18416                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18417                                                                   /* index at 32 */ && 
18418                                                             (MATCH_w_8_32 >> 3 & 0x7) 
18419                                                                   /* index at 32 */ < 8)) 
18420                                                             goto MATCH_label_c115;  /*opt-block+*/
18421                                                           else 
18422                                                             goto MATCH_label_c114;  /*opt-block+*/
18423                                                           
18424                                                           break;
18425                                                         case 5: 
18426                                                           goto MATCH_label_c116; 
18427                                                           
18428                                                           break;
18429                                                         default: assert(0);
18430                                                       } /* (MATCH_w_8_24 & 0x7) 
18431                                                             -- r_m at 24 --*/ 
18432                                                     break;
18433                                                   case 1: 
18434                                                     MATCH_w_8_32 = 
18435                                                       getByte(4 + MATCH_p); 
18436                                                     if ((MATCH_w_8_24 & 0x7) 
18437                                                             /* r_m at 24 */ == 4 && 
18438                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18439                                                             /* index at 32 */ && 
18440                                                       (MATCH_w_8_32 >> 3 & 0x7) 
18441                                                             /* index at 32 */ < 8)) { 
18442                                                       unsigned Eaddr = 
18443                                                         3 + 
18444                                                         addressToPC(MATCH_p);
18445                                                       unsigned reg = 
18446                                                         (MATCH_w_8_24 >> 3 & 0x7) 
18447                                                               /* reg_opcode at 24 */;
18448                                                       nextPC = 6 + MATCH_p; 
18449                                                       
18450 #line 1169 "frontend/machine/pentium/decoder.m"
18451                                                       
18452 
18453                                                             stmts = instantiate(pc,  "IMULrmow", DIS_REG16, DIS_EADDR16);
18454 
18455                                                       
18456 
18457                                                       
18458                                                       
18459                                                       
18460                                                     } /*opt-block*//*opt-block+*/
18461                                                     else 
18462                                                       goto MATCH_label_c114;  /*opt-block+*/
18463                                                     
18464                                                     break;
18465                                                   case 2: 
18466                                                     MATCH_w_8_32 = 
18467                                                       getByte(4 + MATCH_p); 
18468                                                     if ((MATCH_w_8_24 & 0x7) 
18469                                                             /* r_m at 24 */ == 4 && 
18470                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18471                                                             /* index at 32 */ && 
18472                                                       (MATCH_w_8_32 >> 3 & 0x7) 
18473                                                             /* index at 32 */ < 8)) 
18474                                                       goto MATCH_label_c115;  /*opt-block+*/
18475                                                     else 
18476                                                       goto MATCH_label_c116;  /*opt-block+*/
18477                                                     
18478                                                     break;
18479                                                   case 3: 
18480                                                     goto MATCH_label_c113; 
18481                                                     
18482                                                     break;
18483                                                   default: assert(0);
18484                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
18485                                                       -- mod at 24 --*/ 
18486                                               
18487                                             } /*opt-block*/
18488                                             else 
18489                                               goto MATCH_label_c64;  /*opt-block+*/
18490                                             break;
18491                                           default: assert(0);
18492                                         } /* (MATCH_w_8_16 & 0x7) 
18493                                               -- col at 16 --*/ 
18494                                       break;
18495                                     case 11: 
18496                                       
18497                                         switch((MATCH_w_8_16 & 0x7) 
18498                                               /* col at 16 */) {
18499                                           case 0: case 7: 
18500                                             goto MATCH_label_c64; break;
18501                                           case 1: 
18502                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
18503                                                     /* page at 16 */ == 1) 
18504                                               goto MATCH_label_c64;  /*opt-block+*/
18505                                             else { 
18506                                               MATCH_w_8_24 = 
18507                                                 getByte(3 + MATCH_p); 
18508                                               
18509                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
18510                                                       /* mod at 24 */) {
18511                                                   case 0: 
18512                                                     
18513                                                       switch((MATCH_w_8_24 & 0x7) 
18514                                                             /* r_m at 24 */) {
18515                                                         case 0: case 1: 
18516                                                         case 2: case 3: 
18517                                                         case 6: case 7: 
18518                                                           goto MATCH_label_c117; 
18519                                                           
18520                                                           break;
18521                                                         case 4: 
18522                                                           MATCH_w_8_32 = 
18523                                                             getByte(4 + 
18524                                                                   MATCH_p); 
18525                                                           if ((MATCH_w_8_32 & 0x7) 
18526                                                                   /* base at 32 */ == 5 && 
18527                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18528                                                                   /* index at 32 */ && 
18529                                                             (MATCH_w_8_32 >> 3 & 0x7) 
18530                                                                   /* index at 32 */ < 8)) 
18531                                                             goto MATCH_label_c119;  /*opt-block+*/
18532                                                           else 
18533                                                             goto MATCH_label_c118;  /*opt-block+*/
18534                                                           
18535                                                           break;
18536                                                         case 5: 
18537                                                           goto MATCH_label_c120; 
18538                                                           
18539                                                           break;
18540                                                         default: assert(0);
18541                                                       } /* (MATCH_w_8_24 & 0x7) 
18542                                                             -- r_m at 24 --*/ 
18543                                                     break;
18544                                                   case 1: 
18545                                                     MATCH_w_8_32 = 
18546                                                       getByte(4 + MATCH_p); 
18547                                                     if ((MATCH_w_8_24 & 0x7) 
18548                                                             /* r_m at 24 */ == 4 && 
18549                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18550                                                             /* index at 32 */ && 
18551                                                       (MATCH_w_8_32 >> 3 & 0x7) 
18552                                                             /* index at 32 */ < 8)) { 
18553                                                       unsigned Eaddr = 
18554                                                         3 + 
18555                                                         addressToPC(MATCH_p);
18556                                                       unsigned reg = 
18557                                                         (MATCH_w_8_24 >> 3 & 0x7) 
18558                                                               /* reg_opcode at 24 */;
18559                                                       nextPC = 6 + MATCH_p; 
18560                                                       
18561 #line 1241 "frontend/machine/pentium/decoder.m"
18562                                                       
18563 
18564                                                             stmts = instantiate(pc,  "CMPXCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
18565 
18566                                                       
18567 
18568                                                       
18569                                                       
18570                                                       
18571                                                     } /*opt-block*//*opt-block+*/
18572                                                     else 
18573                                                       goto MATCH_label_c118;  /*opt-block+*/
18574                                                     
18575                                                     break;
18576                                                   case 2: 
18577                                                     MATCH_w_8_32 = 
18578                                                       getByte(4 + MATCH_p); 
18579                                                     if ((MATCH_w_8_24 & 0x7) 
18580                                                             /* r_m at 24 */ == 4 && 
18581                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18582                                                             /* index at 32 */ && 
18583                                                       (MATCH_w_8_32 >> 3 & 0x7) 
18584                                                             /* index at 32 */ < 8)) 
18585                                                       goto MATCH_label_c119;  /*opt-block+*/
18586                                                     else 
18587                                                       goto MATCH_label_c120;  /*opt-block+*/
18588                                                     
18589                                                     break;
18590                                                   case 3: 
18591                                                     goto MATCH_label_c117; 
18592                                                     
18593                                                     break;
18594                                                   default: assert(0);
18595                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
18596                                                       -- mod at 24 --*/ 
18597                                               
18598                                             } /*opt-block*/
18599                                             break;
18600                                           case 2: 
18601                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
18602                                                     /* page at 16 */ == 1) { 
18603                                               MATCH_w_8_24 = 
18604                                                 getByte(3 + MATCH_p); 
18605                                               
18606                                                 switch((MATCH_w_8_24 >> 3 & 0x7) 
18607                                                       /* reg_opcode at 24 */) {
18608                                                   case 0: case 1: case 2: 
18609                                                   case 3: 
18610                                                     goto MATCH_label_c64; 
18611                                                     
18612                                                     break;
18613                                                   case 4: 
18614                                                     
18615                                                       switch((MATCH_w_8_24 >> 6 & 0x3) 
18616                                                             /* mod at 24 */) {
18617                                                         case 0: 
18618                                                           
18619                                                             switch((MATCH_w_8_24 & 0x7) 
18620                                                                   /* r_m at 24 */) {
18621                                                               case 0: case 1: 
18622                                                               case 2: case 3: 
18623                                                               case 6: case 7: 
18624                                                                 MATCH_w_8_32 = 
18625                                                                   getByte(4 + 
18626                                                                         MATCH_p); 
18627                                                                 goto MATCH_label_c121; 
18628                                                                 
18629                                                                 break;
18630                                                               case 4: 
18631                                                                 MATCH_w_8_32 = 
18632                                                                   getByte(4 + 
18633                                                                         MATCH_p); 
18634                                                                 if ((MATCH_w_8_32 & 0x7) 
18635                                                                         /* base at 32 */ == 5 && 
18636                                                                   (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18637                                                                         /* index at 32 */ && 
18638                                                                   (MATCH_w_8_32 >> 3 & 0x7) 
18639                                                                         /* index at 32 */ < 8)) { 
18640                                                                   MATCH_w_8_72 = 
18641                                                                     getByte(9 + 
18642                                                                           MATCH_p); 
18643                                                                   goto MATCH_label_c123; 
18644                                                                   
18645                                                                 } /*opt-block*/
18646                                                                 else { 
18647                                                                   MATCH_w_8_40 = 
18648                                                                     getByte(5 + 
18649                                                                           MATCH_p); 
18650                                                                   goto MATCH_label_c122; 
18651                                                                   
18652                                                                 } /*opt-block*/
18653                                                                 
18654                                                                 break;
18655                                                               case 5: 
18656                                                                 MATCH_w_8_64 = 
18657                                                                   getByte(8 + 
18658                                                                         MATCH_p); 
18659                                                                 goto MATCH_label_c124; 
18660                                                                 
18661                                                                 break;
18662                                                               default: assert(0);
18663                                                             } /* (MATCH_w_8_24 & 0x7) 
18664                                                                   -- r_m at 24 --*/ 
18665                                                           break;
18666                                                         case 1: 
18667                                                           MATCH_w_8_32 = 
18668                                                             getByte(4 + 
18669                                                                   MATCH_p); 
18670                                                           if ((MATCH_w_8_24 & 0x7) 
18671                                                                   /* r_m at 24 */ == 4 && 
18672                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18673                                                                   /* index at 32 */ && 
18674                                                             (MATCH_w_8_32 >> 3 & 0x7) 
18675                                                                   /* index at 32 */ < 8)) { 
18676                                                             MATCH_w_8_48 = 
18677                                                               getByte(6 + 
18678                                                                     MATCH_p); 
18679                                                             { 
18680                                                               unsigned Eaddr = 
18681                                                                 3 + 
18682                                                                 addressToPC(MATCH_p);
18683                                                               int /* [~128..127] */ i8 = 
18684                                                                 sign_extend((MATCH_w_8_48 & 0xff) 
18685                                                                                   /* i8 at 48 */, 
18686                                                                             8);
18687                                                               nextPC = 7 + 
18688                                                               MATCH_p; 
18689                                                               
18690 #line 1349 "frontend/machine/pentium/decoder.m"
18691                                                               
18692 
18693                                                                     stmts = instantiate(pc,  "BTiow", DIS_EADDR16, DIS_I8);
18694 
18695                                                               
18696 
18697                                                               
18698                                                               
18699                                                               
18700                                                             }
18701                                                             
18702                                                           } /*opt-block*/
18703                                                           else { 
18704                                                             MATCH_w_8_40 = 
18705                                                               getByte(5 + 
18706                                                                     MATCH_p); 
18707                                                             goto MATCH_label_c122; 
18708                                                             
18709                                                           } /*opt-block*/
18710                                                           
18711                                                           break;
18712                                                         case 2: 
18713                                                           MATCH_w_8_32 = 
18714                                                             getByte(4 + 
18715                                                                   MATCH_p); 
18716                                                           if ((MATCH_w_8_24 & 0x7) 
18717                                                                   /* r_m at 24 */ == 4 && 
18718                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18719                                                                   /* index at 32 */ && 
18720                                                             (MATCH_w_8_32 >> 3 & 0x7) 
18721                                                                   /* index at 32 */ < 8)) { 
18722                                                             MATCH_w_8_72 = 
18723                                                               getByte(9 + 
18724                                                                     MATCH_p); 
18725                                                             goto MATCH_label_c123; 
18726                                                             
18727                                                           } /*opt-block*/
18728                                                           else { 
18729                                                             MATCH_w_8_64 = 
18730                                                               getByte(8 + 
18731                                                                     MATCH_p); 
18732                                                             goto MATCH_label_c124; 
18733                                                             
18734                                                           } /*opt-block*/
18735                                                           
18736                                                           break;
18737                                                         case 3: 
18738                                                           MATCH_w_8_32 = 
18739                                                             getByte(4 + 
18740                                                                   MATCH_p); 
18741                                                           goto MATCH_label_c121; 
18742                                                           
18743                                                           break;
18744                                                         default: assert(0);
18745                                                       } /* (MATCH_w_8_24 >> 6 & 0x3) 
18746                                                             -- mod at 24 --*/ 
18747                                                     break;
18748                                                   case 5: 
18749                                                     
18750                                                       switch((MATCH_w_8_24 >> 6 & 0x3) 
18751                                                             /* mod at 24 */) {
18752                                                         case 0: 
18753                                                           
18754                                                             switch((MATCH_w_8_24 & 0x7) 
18755                                                                   /* r_m at 24 */) {
18756                                                               case 0: case 1: 
18757                                                               case 2: case 3: 
18758                                                               case 6: case 7: 
18759                                                                 MATCH_w_8_32 = 
18760                                                                   getByte(4 + 
18761                                                                         MATCH_p); 
18762                                                                 goto MATCH_label_c125; 
18763                                                                 
18764                                                                 break;
18765                                                               case 4: 
18766                                                                 MATCH_w_8_32 = 
18767                                                                   getByte(4 + 
18768                                                                         MATCH_p); 
18769                                                                 if ((MATCH_w_8_32 & 0x7) 
18770                                                                         /* base at 32 */ == 5 && 
18771                                                                   (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18772                                                                         /* index at 32 */ && 
18773                                                                   (MATCH_w_8_32 >> 3 & 0x7) 
18774                                                                         /* index at 32 */ < 8)) { 
18775                                                                   MATCH_w_8_72 = 
18776                                                                     getByte(9 + 
18777                                                                           MATCH_p); 
18778                                                                   goto MATCH_label_c127; 
18779                                                                   
18780                                                                 } /*opt-block*/
18781                                                                 else { 
18782                                                                   MATCH_w_8_40 = 
18783                                                                     getByte(5 + 
18784                                                                           MATCH_p); 
18785                                                                   goto MATCH_label_c126; 
18786                                                                   
18787                                                                 } /*opt-block*/
18788                                                                 
18789                                                                 break;
18790                                                               case 5: 
18791                                                                 MATCH_w_8_64 = 
18792                                                                   getByte(8 + 
18793                                                                         MATCH_p); 
18794                                                                 goto MATCH_label_c128; 
18795                                                                 
18796                                                                 break;
18797                                                               default: assert(0);
18798                                                             } /* (MATCH_w_8_24 & 0x7) 
18799                                                                   -- r_m at 24 --*/ 
18800                                                           break;
18801                                                         case 1: 
18802                                                           MATCH_w_8_32 = 
18803                                                             getByte(4 + 
18804                                                                   MATCH_p); 
18805                                                           if ((MATCH_w_8_24 & 0x7) 
18806                                                                   /* r_m at 24 */ == 4 && 
18807                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18808                                                                   /* index at 32 */ && 
18809                                                             (MATCH_w_8_32 >> 3 & 0x7) 
18810                                                                   /* index at 32 */ < 8)) { 
18811                                                             MATCH_w_8_48 = 
18812                                                               getByte(6 + 
18813                                                                     MATCH_p); 
18814                                                             { 
18815                                                               unsigned Eaddr = 
18816                                                                 3 + 
18817                                                                 addressToPC(MATCH_p);
18818                                                               int /* [~128..127] */ i8 = 
18819                                                                 sign_extend((MATCH_w_8_48 & 0xff) 
18820                                                                                   /* i8 at 48 */, 
18821                                                                             8);
18822                                                               nextPC = 7 + 
18823                                                               MATCH_p; 
18824                                                               
18825 #line 1313 "frontend/machine/pentium/decoder.m"
18826                                                               
18827 
18828                                                                     stmts = instantiate(pc,  "BTSiow", DIS_I8, DIS_EADDR16);
18829 
18830                                                               
18831 
18832                                                               
18833                                                               
18834                                                               
18835                                                             }
18836                                                             
18837                                                           } /*opt-block*/
18838                                                           else { 
18839                                                             MATCH_w_8_40 = 
18840                                                               getByte(5 + 
18841                                                                     MATCH_p); 
18842                                                             goto MATCH_label_c126; 
18843                                                             
18844                                                           } /*opt-block*/
18845                                                           
18846                                                           break;
18847                                                         case 2: 
18848                                                           MATCH_w_8_32 = 
18849                                                             getByte(4 + 
18850                                                                   MATCH_p); 
18851                                                           if ((MATCH_w_8_24 & 0x7) 
18852                                                                   /* r_m at 24 */ == 4 && 
18853                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18854                                                                   /* index at 32 */ && 
18855                                                             (MATCH_w_8_32 >> 3 & 0x7) 
18856                                                                   /* index at 32 */ < 8)) { 
18857                                                             MATCH_w_8_72 = 
18858                                                               getByte(9 + 
18859                                                                     MATCH_p); 
18860                                                             goto MATCH_label_c127; 
18861                                                             
18862                                                           } /*opt-block*/
18863                                                           else { 
18864                                                             MATCH_w_8_64 = 
18865                                                               getByte(8 + 
18866                                                                     MATCH_p); 
18867                                                             goto MATCH_label_c128; 
18868                                                             
18869                                                           } /*opt-block*/
18870                                                           
18871                                                           break;
18872                                                         case 3: 
18873                                                           MATCH_w_8_32 = 
18874                                                             getByte(4 + 
18875                                                                   MATCH_p); 
18876                                                           goto MATCH_label_c125; 
18877                                                           
18878                                                           break;
18879                                                         default: assert(0);
18880                                                       } /* (MATCH_w_8_24 >> 6 & 0x3) 
18881                                                             -- mod at 24 --*/ 
18882                                                     break;
18883                                                   case 6: 
18884                                                     
18885                                                       switch((MATCH_w_8_24 >> 6 & 0x3) 
18886                                                             /* mod at 24 */) {
18887                                                         case 0: 
18888                                                           
18889                                                             switch((MATCH_w_8_24 & 0x7) 
18890                                                                   /* r_m at 24 */) {
18891                                                               case 0: case 1: 
18892                                                               case 2: case 3: 
18893                                                               case 6: case 7: 
18894                                                                 MATCH_w_8_32 = 
18895                                                                   getByte(4 + 
18896                                                                         MATCH_p); 
18897                                                                 goto MATCH_label_c129; 
18898                                                                 
18899                                                                 break;
18900                                                               case 4: 
18901                                                                 MATCH_w_8_32 = 
18902                                                                   getByte(4 + 
18903                                                                         MATCH_p); 
18904                                                                 if ((MATCH_w_8_32 & 0x7) 
18905                                                                         /* base at 32 */ == 5 && 
18906                                                                   (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18907                                                                         /* index at 32 */ && 
18908                                                                   (MATCH_w_8_32 >> 3 & 0x7) 
18909                                                                         /* index at 32 */ < 8)) { 
18910                                                                   MATCH_w_8_72 = 
18911                                                                     getByte(9 + 
18912                                                                           MATCH_p); 
18913                                                                   goto MATCH_label_c131; 
18914                                                                   
18915                                                                 } /*opt-block*/
18916                                                                 else { 
18917                                                                   MATCH_w_8_40 = 
18918                                                                     getByte(5 + 
18919                                                                           MATCH_p); 
18920                                                                   goto MATCH_label_c130; 
18921                                                                   
18922                                                                 } /*opt-block*/
18923                                                                 
18924                                                                 break;
18925                                                               case 5: 
18926                                                                 MATCH_w_8_64 = 
18927                                                                   getByte(8 + 
18928                                                                         MATCH_p); 
18929                                                                 goto MATCH_label_c132; 
18930                                                                 
18931                                                                 break;
18932                                                               default: assert(0);
18933                                                             } /* (MATCH_w_8_24 & 0x7) 
18934                                                                   -- r_m at 24 --*/ 
18935                                                           break;
18936                                                         case 1: 
18937                                                           MATCH_w_8_32 = 
18938                                                             getByte(4 + 
18939                                                                   MATCH_p); 
18940                                                           if ((MATCH_w_8_24 & 0x7) 
18941                                                                   /* r_m at 24 */ == 4 && 
18942                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18943                                                                   /* index at 32 */ && 
18944                                                             (MATCH_w_8_32 >> 3 & 0x7) 
18945                                                                   /* index at 32 */ < 8)) { 
18946                                                             MATCH_w_8_48 = 
18947                                                               getByte(6 + 
18948                                                                     MATCH_p); 
18949                                                             { 
18950                                                               unsigned Eaddr = 
18951                                                                 3 + 
18952                                                                 addressToPC(MATCH_p);
18953                                                               int /* [~128..127] */ i8 = 
18954                                                                 sign_extend((MATCH_w_8_48 & 0xff) 
18955                                                                                   /* i8 at 48 */, 
18956                                                                             8);
18957                                                               nextPC = 7 + 
18958                                                               MATCH_p; 
18959                                                               
18960 #line 1325 "frontend/machine/pentium/decoder.m"
18961                                                               
18962 
18963                                                                     stmts = instantiate(pc,  "BTRiow", DIS_EADDR16, DIS_I8);
18964 
18965                                                               
18966 
18967                                                               
18968                                                               
18969                                                               
18970                                                             }
18971                                                             
18972                                                           } /*opt-block*/
18973                                                           else { 
18974                                                             MATCH_w_8_40 = 
18975                                                               getByte(5 + 
18976                                                                     MATCH_p); 
18977                                                             goto MATCH_label_c130; 
18978                                                             
18979                                                           } /*opt-block*/
18980                                                           
18981                                                           break;
18982                                                         case 2: 
18983                                                           MATCH_w_8_32 = 
18984                                                             getByte(4 + 
18985                                                                   MATCH_p); 
18986                                                           if ((MATCH_w_8_24 & 0x7) 
18987                                                                   /* r_m at 24 */ == 4 && 
18988                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
18989                                                                   /* index at 32 */ && 
18990                                                             (MATCH_w_8_32 >> 3 & 0x7) 
18991                                                                   /* index at 32 */ < 8)) { 
18992                                                             MATCH_w_8_72 = 
18993                                                               getByte(9 + 
18994                                                                     MATCH_p); 
18995                                                             goto MATCH_label_c131; 
18996                                                             
18997                                                           } /*opt-block*/
18998                                                           else { 
18999                                                             MATCH_w_8_64 = 
19000                                                               getByte(8 + 
19001                                                                     MATCH_p); 
19002                                                             goto MATCH_label_c132; 
19003                                                             
19004                                                           } /*opt-block*/
19005                                                           
19006                                                           break;
19007                                                         case 3: 
19008                                                           MATCH_w_8_32 = 
19009                                                             getByte(4 + 
19010                                                                   MATCH_p); 
19011                                                           goto MATCH_label_c129; 
19012                                                           
19013                                                           break;
19014                                                         default: assert(0);
19015                                                       } /* (MATCH_w_8_24 >> 6 & 0x3) 
19016                                                             -- mod at 24 --*/ 
19017                                                     break;
19018                                                   case 7: 
19019                                                     
19020                                                       switch((MATCH_w_8_24 >> 6 & 0x3) 
19021                                                             /* mod at 24 */) {
19022                                                         case 0: 
19023                                                           
19024                                                             switch((MATCH_w_8_24 & 0x7) 
19025                                                                   /* r_m at 24 */) {
19026                                                               case 0: case 1: 
19027                                                               case 2: case 3: 
19028                                                               case 6: case 7: 
19029                                                                 MATCH_w_8_32 = 
19030                                                                   getByte(4 + 
19031                                                                         MATCH_p); 
19032                                                                 goto MATCH_label_c133; 
19033                                                                 
19034                                                                 break;
19035                                                               case 4: 
19036                                                                 MATCH_w_8_32 = 
19037                                                                   getByte(4 + 
19038                                                                         MATCH_p); 
19039                                                                 if ((MATCH_w_8_32 & 0x7) 
19040                                                                         /* base at 32 */ == 5 && 
19041                                                                   (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19042                                                                         /* index at 32 */ && 
19043                                                                   (MATCH_w_8_32 >> 3 & 0x7) 
19044                                                                         /* index at 32 */ < 8)) { 
19045                                                                   MATCH_w_8_72 = 
19046                                                                     getByte(9 + 
19047                                                                           MATCH_p); 
19048                                                                   goto MATCH_label_c135; 
19049                                                                   
19050                                                                 } /*opt-block*/
19051                                                                 else { 
19052                                                                   MATCH_w_8_40 = 
19053                                                                     getByte(5 + 
19054                                                                           MATCH_p); 
19055                                                                   goto MATCH_label_c134; 
19056                                                                   
19057                                                                 } /*opt-block*/
19058                                                                 
19059                                                                 break;
19060                                                               case 5: 
19061                                                                 MATCH_w_8_64 = 
19062                                                                   getByte(8 + 
19063                                                                         MATCH_p); 
19064                                                                 goto MATCH_label_c136; 
19065                                                                 
19066                                                                 break;
19067                                                               default: assert(0);
19068                                                             } /* (MATCH_w_8_24 & 0x7) 
19069                                                                   -- r_m at 24 --*/ 
19070                                                           break;
19071                                                         case 1: 
19072                                                           MATCH_w_8_32 = 
19073                                                             getByte(4 + 
19074                                                                   MATCH_p); 
19075                                                           if ((MATCH_w_8_24 & 0x7) 
19076                                                                   /* r_m at 24 */ == 4 && 
19077                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19078                                                                   /* index at 32 */ && 
19079                                                             (MATCH_w_8_32 >> 3 & 0x7) 
19080                                                                   /* index at 32 */ < 8)) { 
19081                                                             MATCH_w_8_48 = 
19082                                                               getByte(6 + 
19083                                                                     MATCH_p); 
19084                                                             { 
19085                                                               unsigned Eaddr = 
19086                                                                 3 + 
19087                                                                 addressToPC(MATCH_p);
19088                                                               int /* [~128..127] */ i8 = 
19089                                                                 sign_extend((MATCH_w_8_48 & 0xff) 
19090                                                                                   /* i8 at 48 */, 
19091                                                                             8);
19092                                                               nextPC = 7 + 
19093                                                               MATCH_p; 
19094                                                               
19095 #line 1337 "frontend/machine/pentium/decoder.m"
19096                                                               
19097 
19098                                                                     stmts = instantiate(pc,  "BTCiow", DIS_EADDR16, DIS_I8);
19099 
19100                                                               
19101 
19102                                                               
19103                                                               
19104                                                               
19105                                                             }
19106                                                             
19107                                                           } /*opt-block*/
19108                                                           else { 
19109                                                             MATCH_w_8_40 = 
19110                                                               getByte(5 + 
19111                                                                     MATCH_p); 
19112                                                             goto MATCH_label_c134; 
19113                                                             
19114                                                           } /*opt-block*/
19115                                                           
19116                                                           break;
19117                                                         case 2: 
19118                                                           MATCH_w_8_32 = 
19119                                                             getByte(4 + 
19120                                                                   MATCH_p); 
19121                                                           if ((MATCH_w_8_24 & 0x7) 
19122                                                                   /* r_m at 24 */ == 4 && 
19123                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19124                                                                   /* index at 32 */ && 
19125                                                             (MATCH_w_8_32 >> 3 & 0x7) 
19126                                                                   /* index at 32 */ < 8)) { 
19127                                                             MATCH_w_8_72 = 
19128                                                               getByte(9 + 
19129                                                                     MATCH_p); 
19130                                                             goto MATCH_label_c135; 
19131                                                             
19132                                                           } /*opt-block*/
19133                                                           else { 
19134                                                             MATCH_w_8_64 = 
19135                                                               getByte(8 + 
19136                                                                     MATCH_p); 
19137                                                             goto MATCH_label_c136; 
19138                                                             
19139                                                           } /*opt-block*/
19140                                                           
19141                                                           break;
19142                                                         case 3: 
19143                                                           MATCH_w_8_32 = 
19144                                                             getByte(4 + 
19145                                                                   MATCH_p); 
19146                                                           goto MATCH_label_c133; 
19147                                                           
19148                                                           break;
19149                                                         default: assert(0);
19150                                                       } /* (MATCH_w_8_24 >> 6 & 0x3) 
19151                                                             -- mod at 24 --*/ 
19152                                                     break;
19153                                                   default: assert(0);
19154                                                 } /* (MATCH_w_8_24 >> 3 & 0x7) 
19155                                                       -- reg_opcode at 24 --*/ 
19156                                               
19157                                             } /*opt-block*/
19158                                             else 
19159                                               goto MATCH_label_c64;  /*opt-block+*/
19160                                             break;
19161                                           case 3: 
19162                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
19163                                                     /* page at 16 */ == 1) { 
19164                                               MATCH_w_8_24 = 
19165                                                 getByte(3 + MATCH_p); 
19166                                               
19167                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
19168                                                       /* mod at 24 */) {
19169                                                   case 0: 
19170                                                     
19171                                                       switch((MATCH_w_8_24 & 0x7) 
19172                                                             /* r_m at 24 */) {
19173                                                         case 0: case 1: 
19174                                                         case 2: case 3: 
19175                                                         case 6: case 7: 
19176                                                           goto MATCH_label_c141; 
19177                                                           
19178                                                           break;
19179                                                         case 4: 
19180                                                           MATCH_w_8_32 = 
19181                                                             getByte(4 + 
19182                                                                   MATCH_p); 
19183                                                           if ((MATCH_w_8_32 & 0x7) 
19184                                                                   /* base at 32 */ == 5 && 
19185                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19186                                                                   /* index at 32 */ && 
19187                                                             (MATCH_w_8_32 >> 3 & 0x7) 
19188                                                                   /* index at 32 */ < 8)) 
19189                                                             goto MATCH_label_c143;  /*opt-block+*/
19190                                                           else 
19191                                                             goto MATCH_label_c142;  /*opt-block+*/
19192                                                           
19193                                                           break;
19194                                                         case 5: 
19195                                                           goto MATCH_label_c144; 
19196                                                           
19197                                                           break;
19198                                                         default: assert(0);
19199                                                       } /* (MATCH_w_8_24 & 0x7) 
19200                                                             -- r_m at 24 --*/ 
19201                                                     break;
19202                                                   case 1: 
19203                                                     MATCH_w_8_32 = 
19204                                                       getByte(4 + MATCH_p); 
19205                                                     if ((MATCH_w_8_24 & 0x7) 
19206                                                             /* r_m at 24 */ == 4 && 
19207                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19208                                                             /* index at 32 */ && 
19209                                                       (MATCH_w_8_32 >> 3 & 0x7) 
19210                                                             /* index at 32 */ < 8)) { 
19211                                                       unsigned Eaddr = 
19212                                                         3 + 
19213                                                         addressToPC(MATCH_p);
19214                                                       unsigned reg = 
19215                                                         (MATCH_w_8_24 >> 3 & 0x7) 
19216                                                               /* reg_opcode at 24 */;
19217                                                       nextPC = 6 + MATCH_p; 
19218                                                       
19219 #line 1343 "frontend/machine/pentium/decoder.m"
19220                                                       
19221 
19222                                                             stmts = instantiate(pc,  "BTCow", DIS_EADDR16, DIS_REG16);
19223 
19224                                                       
19225 
19226                                                       
19227                                                       
19228                                                       
19229                                                     } /*opt-block*//*opt-block+*/
19230                                                     else 
19231                                                       goto MATCH_label_c142;  /*opt-block+*/
19232                                                     
19233                                                     break;
19234                                                   case 2: 
19235                                                     MATCH_w_8_32 = 
19236                                                       getByte(4 + MATCH_p); 
19237                                                     if ((MATCH_w_8_24 & 0x7) 
19238                                                             /* r_m at 24 */ == 4 && 
19239                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19240                                                             /* index at 32 */ && 
19241                                                       (MATCH_w_8_32 >> 3 & 0x7) 
19242                                                             /* index at 32 */ < 8)) 
19243                                                       goto MATCH_label_c143;  /*opt-block+*/
19244                                                     else 
19245                                                       goto MATCH_label_c144;  /*opt-block+*/
19246                                                     
19247                                                     break;
19248                                                   case 3: 
19249                                                     goto MATCH_label_c141; 
19250                                                     
19251                                                     break;
19252                                                   default: assert(0);
19253                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
19254                                                       -- mod at 24 --*/ 
19255                                               
19256                                             } /*opt-block*/
19257                                             else { 
19258                                               MATCH_w_8_24 = 
19259                                                 getByte(3 + MATCH_p); 
19260                                               
19261                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
19262                                                       /* mod at 24 */) {
19263                                                   case 0: 
19264                                                     
19265                                                       switch((MATCH_w_8_24 & 0x7) 
19266                                                             /* r_m at 24 */) {
19267                                                         case 0: case 1: 
19268                                                         case 2: case 3: 
19269                                                         case 6: case 7: 
19270                                                           goto MATCH_label_c137; 
19271                                                           
19272                                                           break;
19273                                                         case 4: 
19274                                                           MATCH_w_8_32 = 
19275                                                             getByte(4 + 
19276                                                                   MATCH_p); 
19277                                                           if ((MATCH_w_8_32 & 0x7) 
19278                                                                   /* base at 32 */ == 5 && 
19279                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19280                                                                   /* index at 32 */ && 
19281                                                             (MATCH_w_8_32 >> 3 & 0x7) 
19282                                                                   /* index at 32 */ < 8)) 
19283                                                             goto MATCH_label_c139;  /*opt-block+*/
19284                                                           else 
19285                                                             goto MATCH_label_c138;  /*opt-block+*/
19286                                                           
19287                                                           break;
19288                                                         case 5: 
19289                                                           goto MATCH_label_c140; 
19290                                                           
19291                                                           break;
19292                                                         default: assert(0);
19293                                                       } /* (MATCH_w_8_24 & 0x7) 
19294                                                             -- r_m at 24 --*/ 
19295                                                     break;
19296                                                   case 1: 
19297                                                     MATCH_w_8_32 = 
19298                                                       getByte(4 + MATCH_p); 
19299                                                     if ((MATCH_w_8_24 & 0x7) 
19300                                                             /* r_m at 24 */ == 4 && 
19301                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19302                                                             /* index at 32 */ && 
19303                                                       (MATCH_w_8_32 >> 3 & 0x7) 
19304                                                             /* index at 32 */ < 8)) { 
19305                                                       unsigned Eaddr = 
19306                                                         3 + 
19307                                                         addressToPC(MATCH_p);
19308                                                       unsigned reg = 
19309                                                         (MATCH_w_8_24 >> 3 & 0x7) 
19310                                                               /* reg_opcode at 24 */;
19311                                                       nextPC = 6 + MATCH_p; 
19312                                                       
19313 #line 1331 "frontend/machine/pentium/decoder.m"
19314                                                       
19315 
19316                                                             stmts = instantiate(pc,  "BTRow", DIS_EADDR16, DIS_REG16);
19317 
19318                                                       
19319 
19320                                                       
19321                                                       
19322                                                       
19323                                                     } /*opt-block*//*opt-block+*/
19324                                                     else 
19325                                                       goto MATCH_label_c138;  /*opt-block+*/
19326                                                     
19327                                                     break;
19328                                                   case 2: 
19329                                                     MATCH_w_8_32 = 
19330                                                       getByte(4 + MATCH_p); 
19331                                                     if ((MATCH_w_8_24 & 0x7) 
19332                                                             /* r_m at 24 */ == 4 && 
19333                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19334                                                             /* index at 32 */ && 
19335                                                       (MATCH_w_8_32 >> 3 & 0x7) 
19336                                                             /* index at 32 */ < 8)) 
19337                                                       goto MATCH_label_c139;  /*opt-block+*/
19338                                                     else 
19339                                                       goto MATCH_label_c140;  /*opt-block+*/
19340                                                     
19341                                                     break;
19342                                                   case 3: 
19343                                                     goto MATCH_label_c137; 
19344                                                     
19345                                                     break;
19346                                                   default: assert(0);
19347                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
19348                                                       -- mod at 24 --*/ 
19349                                               
19350                                             } /*opt-block*/
19351                                             break;
19352                                           case 4: 
19353                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
19354                                                     /* page at 16 */ == 1) { 
19355                                               MATCH_w_8_24 = 
19356                                                 getByte(3 + MATCH_p); 
19357                                               
19358                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
19359                                                       /* mod at 24 */) {
19360                                                   case 0: 
19361                                                     
19362                                                       switch((MATCH_w_8_24 & 0x7) 
19363                                                             /* r_m at 24 */) {
19364                                                         case 0: case 1: 
19365                                                         case 2: case 3: 
19366                                                         case 6: case 7: 
19367                                                           goto MATCH_label_c145; 
19368                                                           
19369                                                           break;
19370                                                         case 4: 
19371                                                           MATCH_w_8_32 = 
19372                                                             getByte(4 + 
19373                                                                   MATCH_p); 
19374                                                           if ((MATCH_w_8_32 & 0x7) 
19375                                                                   /* base at 32 */ == 5 && 
19376                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19377                                                                   /* index at 32 */ && 
19378                                                             (MATCH_w_8_32 >> 3 & 0x7) 
19379                                                                   /* index at 32 */ < 8)) 
19380                                                             goto MATCH_label_c147;  /*opt-block+*/
19381                                                           else 
19382                                                             goto MATCH_label_c146;  /*opt-block+*/
19383                                                           
19384                                                           break;
19385                                                         case 5: 
19386                                                           goto MATCH_label_c148; 
19387                                                           
19388                                                           break;
19389                                                         default: assert(0);
19390                                                       } /* (MATCH_w_8_24 & 0x7) 
19391                                                             -- r_m at 24 --*/ 
19392                                                     break;
19393                                                   case 1: 
19394                                                     MATCH_w_8_32 = 
19395                                                       getByte(4 + MATCH_p); 
19396                                                     if ((MATCH_w_8_24 & 0x7) 
19397                                                             /* r_m at 24 */ == 4 && 
19398                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19399                                                             /* index at 32 */ && 
19400                                                       (MATCH_w_8_32 >> 3 & 0x7) 
19401                                                             /* index at 32 */ < 8)) { 
19402                                                       unsigned Eaddr = 
19403                                                         3 + 
19404                                                         addressToPC(MATCH_p);
19405                                                       unsigned reg = 
19406                                                         (MATCH_w_8_24 >> 3 & 0x7) 
19407                                                               /* reg_opcode at 24 */;
19408                                                       nextPC = 6 + MATCH_p; 
19409                                                       
19410 #line 1377 "frontend/machine/pentium/decoder.m"
19411                                                       
19412 
19413                                                             //stmts = instantiate(pc,  "BSFow", DIS_REG16, DIS_EADDR16);
19414 
19415                                                             genBSFR(pc, DIS_REG16, DIS_EADDR16, -1, 16, opPlus, nextPC-hostPC);
19416 
19417                                                             return result;
19418 
19419                                                       
19420 
19421                                                         // Not "user" instructions:
19422 
19423                                                       //    | BOUNDod(reg, Mem) =>
19424 
19425                                                       //        stmts = instantiate(pc,  "BOUNDod", DIS_REG32, DIS_MEM);
19426 
19427                                                       
19428 
19429                                                       //    | BOUNDow(reg, Mem) =>
19430 
19431                                                       //        stmts = instantiate(pc,  "BOUNDow", DIS_REG16, DIS_MEM);
19432 
19433                                                       
19434 
19435                                                       //      | ARPL(Eaddr, reg ) =>
19436 
19437                                                       //          unused(Eaddr); unused(reg);
19438 
19439                                                       //          stmts = instantiate(pc,  "UNIMP");
19440 
19441                                                       
19442 
19443                                                       //      | AAS() =>
19444 
19445                                                       //          stmts = instantiate(pc,  "AAS");
19446 
19447                                                       
19448 
19449                                                       //      | AAM() =>
19450 
19451                                                       //          stmts = instantiate(pc,  "AAM");
19452 
19453                                                       
19454 
19455                                                       //      | AAD() =>
19456 
19457                                                       //          stmts = instantiate(pc,  "AAD");
19458 
19459                                                       
19460 
19461                                                       //      | AAA() =>
19462 
19463                                                       //          stmts = instantiate(pc,  "AAA");
19464 
19465                                                       
19466 
19467                                                       
19468                                                       
19469                                                       
19470                                                     } /*opt-block*//*opt-block+*/
19471                                                     else 
19472                                                       goto MATCH_label_c146;  /*opt-block+*/
19473                                                     
19474                                                     break;
19475                                                   case 2: 
19476                                                     MATCH_w_8_32 = 
19477                                                       getByte(4 + MATCH_p); 
19478                                                     if ((MATCH_w_8_24 & 0x7) 
19479                                                             /* r_m at 24 */ == 4 && 
19480                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19481                                                             /* index at 32 */ && 
19482                                                       (MATCH_w_8_32 >> 3 & 0x7) 
19483                                                             /* index at 32 */ < 8)) 
19484                                                       goto MATCH_label_c147;  /*opt-block+*/
19485                                                     else 
19486                                                       goto MATCH_label_c148;  /*opt-block+*/
19487                                                     
19488                                                     break;
19489                                                   case 3: 
19490                                                     goto MATCH_label_c145; 
19491                                                     
19492                                                     break;
19493                                                   default: assert(0);
19494                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
19495                                                       -- mod at 24 --*/ 
19496                                               
19497                                             } /*opt-block*/
19498                                             else 
19499                                               goto MATCH_label_c64;  /*opt-block+*/
19500                                             break;
19501                                           case 5: 
19502                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
19503                                                     /* page at 16 */ == 1) { 
19504                                               MATCH_w_8_24 = 
19505                                                 getByte(3 + MATCH_p); 
19506                                               
19507                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
19508                                                       /* mod at 24 */) {
19509                                                   case 0: 
19510                                                     
19511                                                       switch((MATCH_w_8_24 & 0x7) 
19512                                                             /* r_m at 24 */) {
19513                                                         case 0: case 1: 
19514                                                         case 2: case 3: 
19515                                                         case 6: case 7: 
19516                                                           goto MATCH_label_c149; 
19517                                                           
19518                                                           break;
19519                                                         case 4: 
19520                                                           MATCH_w_8_32 = 
19521                                                             getByte(4 + 
19522                                                                   MATCH_p); 
19523                                                           if ((MATCH_w_8_32 & 0x7) 
19524                                                                   /* base at 32 */ == 5 && 
19525                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19526                                                                   /* index at 32 */ && 
19527                                                             (MATCH_w_8_32 >> 3 & 0x7) 
19528                                                                   /* index at 32 */ < 8)) 
19529                                                             goto MATCH_label_c151;  /*opt-block+*/
19530                                                           else 
19531                                                             goto MATCH_label_c150;  /*opt-block+*/
19532                                                           
19533                                                           break;
19534                                                         case 5: 
19535                                                           goto MATCH_label_c152; 
19536                                                           
19537                                                           break;
19538                                                         default: assert(0);
19539                                                       } /* (MATCH_w_8_24 & 0x7) 
19540                                                             -- r_m at 24 --*/ 
19541                                                     break;
19542                                                   case 1: 
19543                                                     MATCH_w_8_32 = 
19544                                                       getByte(4 + MATCH_p); 
19545                                                     if ((MATCH_w_8_24 & 0x7) 
19546                                                             /* r_m at 24 */ == 4 && 
19547                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19548                                                             /* index at 32 */ && 
19549                                                       (MATCH_w_8_32 >> 3 & 0x7) 
19550                                                             /* index at 32 */ < 8)) { 
19551                                                       unsigned Eaddr = 
19552                                                         3 + 
19553                                                         addressToPC(MATCH_p);
19554                                                       unsigned reg = 
19555                                                         (MATCH_w_8_24 >> 3 & 0x7) 
19556                                                               /* reg_opcode at 24 */;
19557                                                       nextPC = 6 + MATCH_p; 
19558                                                       
19559 #line 1367 "frontend/machine/pentium/decoder.m"
19560                                                       
19561 
19562                                                             //stmts = instantiate(pc,  "BSRow", DIS_REG16, DIS_EADDR16);
19563 
19564                                                             genBSFR(pc, DIS_REG16, DIS_EADDR16, 16, 16, opMinus, nextPC-hostPC);
19565 
19566                                                             return result;
19567 
19568                                                       
19569 
19570                                                       
19571                                                       
19572                                                       
19573                                                     } /*opt-block*//*opt-block+*/
19574                                                     else 
19575                                                       goto MATCH_label_c150;  /*opt-block+*/
19576                                                     
19577                                                     break;
19578                                                   case 2: 
19579                                                     MATCH_w_8_32 = 
19580                                                       getByte(4 + MATCH_p); 
19581                                                     if ((MATCH_w_8_24 & 0x7) 
19582                                                             /* r_m at 24 */ == 4 && 
19583                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19584                                                             /* index at 32 */ && 
19585                                                       (MATCH_w_8_32 >> 3 & 0x7) 
19586                                                             /* index at 32 */ < 8)) 
19587                                                       goto MATCH_label_c151;  /*opt-block+*/
19588                                                     else 
19589                                                       goto MATCH_label_c152;  /*opt-block+*/
19590                                                     
19591                                                     break;
19592                                                   case 3: 
19593                                                     goto MATCH_label_c149; 
19594                                                     
19595                                                     break;
19596                                                   default: assert(0);
19597                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
19598                                                       -- mod at 24 --*/ 
19599                                               
19600                                             } /*opt-block*/
19601                                             else 
19602                                               goto MATCH_label_c64;  /*opt-block+*/
19603                                             break;
19604                                           case 6: 
19605                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
19606                                                     /* page at 16 */ == 1) { 
19607                                               MATCH_w_8_24 = 
19608                                                 getByte(3 + MATCH_p); 
19609                                               
19610                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
19611                                                       /* mod at 24 */) {
19612                                                   case 0: 
19613                                                     
19614                                                       switch((MATCH_w_8_24 & 0x7) 
19615                                                             /* r_m at 24 */) {
19616                                                         case 0: case 1: 
19617                                                         case 2: case 3: 
19618                                                         case 6: case 7: 
19619                                                           goto MATCH_label_c157; 
19620                                                           
19621                                                           break;
19622                                                         case 4: 
19623                                                           MATCH_w_8_32 = 
19624                                                             getByte(4 + 
19625                                                                   MATCH_p); 
19626                                                           if ((MATCH_w_8_32 & 0x7) 
19627                                                                   /* base at 32 */ == 5 && 
19628                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19629                                                                   /* index at 32 */ && 
19630                                                             (MATCH_w_8_32 >> 3 & 0x7) 
19631                                                                   /* index at 32 */ < 8)) 
19632                                                             goto MATCH_label_c159;  /*opt-block+*/
19633                                                           else 
19634                                                             goto MATCH_label_c158;  /*opt-block+*/
19635                                                           
19636                                                           break;
19637                                                         case 5: 
19638                                                           goto MATCH_label_c160; 
19639                                                           
19640                                                           break;
19641                                                         default: assert(0);
19642                                                       } /* (MATCH_w_8_24 & 0x7) 
19643                                                             -- r_m at 24 --*/ 
19644                                                     break;
19645                                                   case 1: 
19646                                                     MATCH_w_8_32 = 
19647                                                       getByte(4 + MATCH_p); 
19648                                                     if ((MATCH_w_8_24 & 0x7) 
19649                                                             /* r_m at 24 */ == 4 && 
19650                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19651                                                             /* index at 32 */ && 
19652                                                       (MATCH_w_8_32 >> 3 & 0x7) 
19653                                                             /* index at 32 */ < 8)) { 
19654                                                       unsigned Eaddr = 
19655                                                         3 + 
19656                                                         addressToPC(MATCH_p);
19657                                                       unsigned r16 = 
19658                                                         (MATCH_w_8_24 >> 3 & 0x7) 
19659                                                               /* reg_opcode at 24 */;
19660                                                       nextPC = 6 + MATCH_p; 
19661                                                       
19662 #line 952 "frontend/machine/pentium/decoder.m"
19663                                                       
19664 
19665                                                             stmts = instantiate(pc,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
19666 
19667                                                       
19668 
19669                                                       
19670                                                       
19671                                                       
19672                                                     } /*opt-block*//*opt-block+*/
19673                                                     else 
19674                                                       goto MATCH_label_c158;  /*opt-block+*/
19675                                                     
19676                                                     break;
19677                                                   case 2: 
19678                                                     MATCH_w_8_32 = 
19679                                                       getByte(4 + MATCH_p); 
19680                                                     if ((MATCH_w_8_24 & 0x7) 
19681                                                             /* r_m at 24 */ == 4 && 
19682                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19683                                                             /* index at 32 */ && 
19684                                                       (MATCH_w_8_32 >> 3 & 0x7) 
19685                                                             /* index at 32 */ < 8)) 
19686                                                       goto MATCH_label_c159;  /*opt-block+*/
19687                                                     else 
19688                                                       goto MATCH_label_c160;  /*opt-block+*/
19689                                                     
19690                                                     break;
19691                                                   case 3: 
19692                                                     goto MATCH_label_c157; 
19693                                                     
19694                                                     break;
19695                                                   default: assert(0);
19696                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
19697                                                       -- mod at 24 --*/ 
19698                                               
19699                                             } /*opt-block*/
19700                                             else { 
19701                                               MATCH_w_8_24 = 
19702                                                 getByte(3 + MATCH_p); 
19703                                               
19704                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
19705                                                       /* mod at 24 */) {
19706                                                   case 0: 
19707                                                     
19708                                                       switch((MATCH_w_8_24 & 0x7) 
19709                                                             /* r_m at 24 */) {
19710                                                         case 0: case 1: 
19711                                                         case 2: case 3: 
19712                                                         case 6: case 7: 
19713                                                           goto MATCH_label_c153; 
19714                                                           
19715                                                           break;
19716                                                         case 4: 
19717                                                           MATCH_w_8_32 = 
19718                                                             getByte(4 + 
19719                                                                   MATCH_p); 
19720                                                           if ((MATCH_w_8_32 & 0x7) 
19721                                                                   /* base at 32 */ == 5 && 
19722                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19723                                                                   /* index at 32 */ && 
19724                                                             (MATCH_w_8_32 >> 3 & 0x7) 
19725                                                                   /* index at 32 */ < 8)) 
19726                                                             goto MATCH_label_c155;  /*opt-block+*/
19727                                                           else 
19728                                                             goto MATCH_label_c154;  /*opt-block+*/
19729                                                           
19730                                                           break;
19731                                                         case 5: 
19732                                                           goto MATCH_label_c156; 
19733                                                           
19734                                                           break;
19735                                                         default: assert(0);
19736                                                       } /* (MATCH_w_8_24 & 0x7) 
19737                                                             -- r_m at 24 --*/ 
19738                                                     break;
19739                                                   case 1: 
19740                                                     MATCH_w_8_32 = 
19741                                                       getByte(4 + MATCH_p); 
19742                                                     if ((MATCH_w_8_24 & 0x7) 
19743                                                             /* r_m at 24 */ == 4 && 
19744                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19745                                                             /* index at 32 */ && 
19746                                                       (MATCH_w_8_32 >> 3 & 0x7) 
19747                                                             /* index at 32 */ < 8)) { 
19748                                                       unsigned Eaddr = 
19749                                                         3 + 
19750                                                         addressToPC(MATCH_p);
19751                                                       unsigned r16 = 
19752                                                         (MATCH_w_8_24 >> 3 & 0x7) 
19753                                                               /* reg_opcode at 24 */;
19754                                                       nextPC = 6 + MATCH_p; 
19755                                                       
19756 #line 943 "frontend/machine/pentium/decoder.m"
19757                                                       
19758 
19759                                                             stmts = instantiate(pc,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
19760 
19761                                                       
19762 
19763                                                       
19764                                                       
19765                                                       
19766                                                     } /*opt-block*//*opt-block+*/
19767                                                     else 
19768                                                       goto MATCH_label_c154;  /*opt-block+*/
19769                                                     
19770                                                     break;
19771                                                   case 2: 
19772                                                     MATCH_w_8_32 = 
19773                                                       getByte(4 + MATCH_p); 
19774                                                     if ((MATCH_w_8_24 & 0x7) 
19775                                                             /* r_m at 24 */ == 4 && 
19776                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19777                                                             /* index at 32 */ && 
19778                                                       (MATCH_w_8_32 >> 3 & 0x7) 
19779                                                             /* index at 32 */ < 8)) 
19780                                                       goto MATCH_label_c155;  /*opt-block+*/
19781                                                     else 
19782                                                       goto MATCH_label_c156;  /*opt-block+*/
19783                                                     
19784                                                     break;
19785                                                   case 3: 
19786                                                     goto MATCH_label_c153; 
19787                                                     
19788                                                     break;
19789                                                   default: assert(0);
19790                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
19791                                                       -- mod at 24 --*/ 
19792                                               
19793                                             } /*opt-block*/
19794                                             break;
19795                                           default: assert(0);
19796                                         } /* (MATCH_w_8_16 & 0x7) 
19797                                               -- col at 16 --*/ 
19798                                       break;
19799                                     case 12: 
19800                                       if ((MATCH_w_8_16 & 0x7) 
19801                                               /* col at 16 */ == 1) 
19802                                         if ((MATCH_w_8_16 >> 3 & 0x1) 
19803                                                 /* page at 16 */ == 1) 
19804                                           goto MATCH_label_c64;  /*opt-block+*/
19805                                         else { 
19806                                           MATCH_w_8_24 = 
19807                                             getByte(3 + MATCH_p); 
19808                                           
19809                                             switch((MATCH_w_8_24 >> 6 & 0x3) 
19810                                                   /* mod at 24 */) {
19811                                               case 0: 
19812                                                 
19813                                                   switch((MATCH_w_8_24 & 0x7) 
19814                                                         /* r_m at 24 */) {
19815                                                     case 0: case 1: case 2: 
19816                                                     case 3: case 6: case 7: 
19817                                                       goto MATCH_label_c161; 
19818                                                       
19819                                                       break;
19820                                                     case 4: 
19821                                                       MATCH_w_8_32 = 
19822                                                         getByte(4 + MATCH_p); 
19823                                                       if ((MATCH_w_8_32 & 0x7) 
19824                                                               /* base at 32 */ == 5 && 
19825                                                         (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19826                                                               /* index at 32 */ && 
19827                                                         (MATCH_w_8_32 >> 3 & 0x7) 
19828                                                               /* index at 32 */ < 8)) 
19829                                                         goto MATCH_label_c163;  /*opt-block+*/
19830                                                       else 
19831                                                         goto MATCH_label_c162;  /*opt-block+*/
19832                                                       
19833                                                       break;
19834                                                     case 5: 
19835                                                       goto MATCH_label_c164; 
19836                                                       
19837                                                       break;
19838                                                     default: assert(0);
19839                                                   } /* (MATCH_w_8_24 & 0x7) 
19840                                                         -- r_m at 24 --*/ 
19841                                                 break;
19842                                               case 1: 
19843                                                 MATCH_w_8_32 = 
19844                                                   getByte(4 + MATCH_p); 
19845                                                 if ((MATCH_w_8_24 & 0x7) 
19846                                                         /* r_m at 24 */ == 4 && 
19847                                                   (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19848                                                         /* index at 32 */ && 
19849                                                   (MATCH_w_8_32 >> 3 & 0x7) 
19850                                                         /* index at 32 */ < 8)) { 
19851                                                   unsigned Eaddr = 
19852                                                     3 + addressToPC(MATCH_p);
19853                                                   unsigned reg = 
19854                                                     (MATCH_w_8_24 >> 3 & 0x7) 
19855                                                           /* reg_opcode at 24 */;
19856                                                   nextPC = 6 + MATCH_p; 
19857                                                   
19858 #line 357 "frontend/machine/pentium/decoder.m"
19859                                                   
19860 
19861                                                         stmts = instantiate(pc,  "XADD.Ev.Gvow", DIS_EADDR16, DIS_REG16);
19862 
19863                                                   
19864 
19865                                                   
19866                                                   
19867                                                   
19868                                                 } /*opt-block*//*opt-block+*/
19869                                                 else 
19870                                                   goto MATCH_label_c162;  /*opt-block+*/
19871                                                 
19872                                                 break;
19873                                               case 2: 
19874                                                 MATCH_w_8_32 = 
19875                                                   getByte(4 + MATCH_p); 
19876                                                 if ((MATCH_w_8_24 & 0x7) 
19877                                                         /* r_m at 24 */ == 4 && 
19878                                                   (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
19879                                                         /* index at 32 */ && 
19880                                                   (MATCH_w_8_32 >> 3 & 0x7) 
19881                                                         /* index at 32 */ < 8)) 
19882                                                   goto MATCH_label_c163;  /*opt-block+*/
19883                                                 else 
19884                                                   goto MATCH_label_c164;  /*opt-block+*/
19885                                                 
19886                                                 break;
19887                                               case 3: 
19888                                                 goto MATCH_label_c161; break;
19889                                               default: assert(0);
19890                                             } /* (MATCH_w_8_24 >> 6 & 0x3) 
19891                                                   -- mod at 24 --*/ 
19892                                           
19893                                         } /*opt-block*/ 
19894                                       else 
19895                                         goto MATCH_label_c64;  /*opt-block+*/
19896                                       break;
19897                                     default: assert(0);
19898                                   } /* (MATCH_w_8_16 >> 4 & 0xf) 
19899                                         -- row at 16 --*/ 
19900                                 
19901                               } /*opt-block*/
19902                               else 
19903                                 goto MATCH_label_c64;  /*opt-block+*/
19904                               break;
19905                             default: assert(0);
19906                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
19907                         break;
19908                       case 1: 
19909                         
19910                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
19911                             case 0: case 2: case 4: case 6: case 7: 
19912                               goto MATCH_label_c64; break;
19913                             case 1: 
19914                               if ((MATCH_w_8_8 >> 3 & 0x1) 
19915                                       /* page at 8 */ == 1) { 
19916                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
19917                                 
19918                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
19919                                         /* mod at 16 */) {
19920                                     case 0: 
19921                                       
19922                                         switch((MATCH_w_8_16 & 0x7) 
19923                                               /* r_m at 16 */) {
19924                                           case 0: case 1: case 2: case 3: 
19925                                           case 6: case 7: 
19926                                             goto MATCH_label_c169; break;
19927                                           case 4: 
19928                                             MATCH_w_8_24 = 
19929                                               getByte(3 + MATCH_p); 
19930                                             if ((MATCH_w_8_24 & 0x7) 
19931                                                     /* base at 24 */ == 5 && 
19932                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
19933                                                     /* index at 24 */ && 
19934                                               (MATCH_w_8_24 >> 3 & 0x7) 
19935                                                     /* index at 24 */ < 8)) 
19936                                               goto MATCH_label_c171;  /*opt-block+*/
19937                                             else 
19938                                               goto MATCH_label_c170;  /*opt-block+*/
19939                                             
19940                                             break;
19941                                           case 5: 
19942                                             goto MATCH_label_c172; break;
19943                                           default: assert(0);
19944                                         } /* (MATCH_w_8_16 & 0x7) 
19945                                               -- r_m at 16 --*/ 
19946                                       break;
19947                                     case 1: 
19948                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
19949                                       if ((MATCH_w_8_16 & 0x7) 
19950                                               /* r_m at 16 */ == 4 && 
19951                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
19952                                               /* index at 24 */ && 
19953                                         (MATCH_w_8_24 >> 3 & 0x7) 
19954                                               /* index at 24 */ < 8)) { 
19955                                         unsigned Eaddr = 
19956                                           2 + addressToPC(MATCH_p);
19957                                         unsigned reg = 
19958                                           (MATCH_w_8_16 >> 3 & 0x7) 
19959                                                 /* reg_opcode at 16 */;
19960                                         nextPC = 5 + MATCH_p; 
19961                                         
19962 #line 1504 "frontend/machine/pentium/decoder.m"
19963                                         
19964 
19965                                                 stmts = instantiate(pc,  "SBBmrow", DIS_EADDR16, DIS_REG16);
19966 
19967                                         
19968 
19969                                         
19970                                         
19971                                         
19972                                       } /*opt-block*//*opt-block+*/
19973                                       else 
19974                                         goto MATCH_label_c170;  /*opt-block+*/
19975                                       
19976                                       break;
19977                                     case 2: 
19978                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
19979                                       if ((MATCH_w_8_16 & 0x7) 
19980                                               /* r_m at 16 */ == 4 && 
19981                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
19982                                               /* index at 24 */ && 
19983                                         (MATCH_w_8_24 >> 3 & 0x7) 
19984                                               /* index at 24 */ < 8)) 
19985                                         goto MATCH_label_c171;  /*opt-block+*/
19986                                       else 
19987                                         goto MATCH_label_c172;  /*opt-block+*/
19988                                       
19989                                       break;
19990                                     case 3: 
19991                                       goto MATCH_label_c169; break;
19992                                     default: assert(0);
19993                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
19994                                         -- mod at 16 --*/ 
19995                                 
19996                               } /*opt-block*/
19997                               else { 
19998                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
19999                                 
20000                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
20001                                         /* mod at 16 */) {
20002                                     case 0: 
20003                                       
20004                                         switch((MATCH_w_8_16 & 0x7) 
20005                                               /* r_m at 16 */) {
20006                                           case 0: case 1: case 2: case 3: 
20007                                           case 6: case 7: 
20008                                             goto MATCH_label_c165; break;
20009                                           case 4: 
20010                                             MATCH_w_8_24 = 
20011                                               getByte(3 + MATCH_p); 
20012                                             if ((MATCH_w_8_24 & 0x7) 
20013                                                     /* base at 24 */ == 5 && 
20014                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20015                                                     /* index at 24 */ && 
20016                                               (MATCH_w_8_24 >> 3 & 0x7) 
20017                                                     /* index at 24 */ < 8)) 
20018                                               goto MATCH_label_c167;  /*opt-block+*/
20019                                             else 
20020                                               goto MATCH_label_c166;  /*opt-block+*/
20021                                             
20022                                             break;
20023                                           case 5: 
20024                                             goto MATCH_label_c168; break;
20025                                           default: assert(0);
20026                                         } /* (MATCH_w_8_16 & 0x7) 
20027                                               -- r_m at 16 --*/ 
20028                                       break;
20029                                     case 1: 
20030                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20031                                       if ((MATCH_w_8_16 & 0x7) 
20032                                               /* r_m at 16 */ == 4 && 
20033                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20034                                               /* index at 24 */ && 
20035                                         (MATCH_w_8_24 >> 3 & 0x7) 
20036                                               /* index at 24 */ < 8)) { 
20037                                         unsigned Eaddr = 
20038                                           2 + addressToPC(MATCH_p);
20039                                         unsigned reg = 
20040                                           (MATCH_w_8_16 >> 3 & 0x7) 
20041                                                 /* reg_opcode at 16 */;
20042                                         nextPC = 5 + MATCH_p; 
20043                                         
20044 #line 1510 "frontend/machine/pentium/decoder.m"
20045                                         
20046 
20047                                                 stmts = instantiate(pc,  "ADCmrow", DIS_EADDR16, DIS_REG16);
20048 
20049                                         
20050 
20051                                         
20052                                         
20053                                         
20054                                       } /*opt-block*//*opt-block+*/
20055                                       else 
20056                                         goto MATCH_label_c166;  /*opt-block+*/
20057                                       
20058                                       break;
20059                                     case 2: 
20060                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20061                                       if ((MATCH_w_8_16 & 0x7) 
20062                                               /* r_m at 16 */ == 4 && 
20063                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20064                                               /* index at 24 */ && 
20065                                         (MATCH_w_8_24 >> 3 & 0x7) 
20066                                               /* index at 24 */ < 8)) 
20067                                         goto MATCH_label_c167;  /*opt-block+*/
20068                                       else 
20069                                         goto MATCH_label_c168;  /*opt-block+*/
20070                                       
20071                                       break;
20072                                     case 3: 
20073                                       goto MATCH_label_c165; break;
20074                                     default: assert(0);
20075                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
20076                                         -- mod at 16 --*/ 
20077                                 
20078                               } /*opt-block*/
20079                               break;
20080                             case 3: 
20081                               if ((MATCH_w_8_8 >> 3 & 0x1) 
20082                                       /* page at 8 */ == 1) { 
20083                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
20084                                 
20085                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
20086                                         /* mod at 16 */) {
20087                                     case 0: 
20088                                       
20089                                         switch((MATCH_w_8_16 & 0x7) 
20090                                               /* r_m at 16 */) {
20091                                           case 0: case 1: case 2: case 3: 
20092                                           case 6: case 7: 
20093                                             goto MATCH_label_c177; break;
20094                                           case 4: 
20095                                             MATCH_w_8_24 = 
20096                                               getByte(3 + MATCH_p); 
20097                                             if ((MATCH_w_8_24 & 0x7) 
20098                                                     /* base at 24 */ == 5 && 
20099                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20100                                                     /* index at 24 */ && 
20101                                               (MATCH_w_8_24 >> 3 & 0x7) 
20102                                                     /* index at 24 */ < 8)) 
20103                                               goto MATCH_label_c179;  /*opt-block+*/
20104                                             else 
20105                                               goto MATCH_label_c178;  /*opt-block+*/
20106                                             
20107                                             break;
20108                                           case 5: 
20109                                             goto MATCH_label_c180; break;
20110                                           default: assert(0);
20111                                         } /* (MATCH_w_8_16 & 0x7) 
20112                                               -- r_m at 16 --*/ 
20113                                       break;
20114                                     case 1: 
20115                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20116                                       if ((MATCH_w_8_16 & 0x7) 
20117                                               /* r_m at 16 */ == 4 && 
20118                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20119                                               /* index at 24 */ && 
20120                                         (MATCH_w_8_24 >> 3 & 0x7) 
20121                                               /* index at 24 */ < 8)) { 
20122                                         unsigned Eaddr = 
20123                                           2 + addressToPC(MATCH_p);
20124                                         unsigned reg = 
20125                                           (MATCH_w_8_16 >> 3 & 0x7) 
20126                                                 /* reg_opcode at 16 */;
20127                                         nextPC = 5 + MATCH_p; 
20128                                         
20129 #line 1432 "frontend/machine/pentium/decoder.m"
20130                                         
20131 
20132                                                 stmts = instantiate(pc,  "SBBrmow", DIS_REG16, DIS_EADDR16);
20133 
20134                                         
20135 
20136                                         
20137                                         
20138                                         
20139                                       } /*opt-block*//*opt-block+*/
20140                                       else 
20141                                         goto MATCH_label_c178;  /*opt-block+*/
20142                                       
20143                                       break;
20144                                     case 2: 
20145                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20146                                       if ((MATCH_w_8_16 & 0x7) 
20147                                               /* r_m at 16 */ == 4 && 
20148                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20149                                               /* index at 24 */ && 
20150                                         (MATCH_w_8_24 >> 3 & 0x7) 
20151                                               /* index at 24 */ < 8)) 
20152                                         goto MATCH_label_c179;  /*opt-block+*/
20153                                       else 
20154                                         goto MATCH_label_c180;  /*opt-block+*/
20155                                       
20156                                       break;
20157                                     case 3: 
20158                                       goto MATCH_label_c177; break;
20159                                     default: assert(0);
20160                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
20161                                         -- mod at 16 --*/ 
20162                                 
20163                               } /*opt-block*/
20164                               else { 
20165                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
20166                                 
20167                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
20168                                         /* mod at 16 */) {
20169                                     case 0: 
20170                                       
20171                                         switch((MATCH_w_8_16 & 0x7) 
20172                                               /* r_m at 16 */) {
20173                                           case 0: case 1: case 2: case 3: 
20174                                           case 6: case 7: 
20175                                             goto MATCH_label_c173; break;
20176                                           case 4: 
20177                                             MATCH_w_8_24 = 
20178                                               getByte(3 + MATCH_p); 
20179                                             if ((MATCH_w_8_24 & 0x7) 
20180                                                     /* base at 24 */ == 5 && 
20181                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20182                                                     /* index at 24 */ && 
20183                                               (MATCH_w_8_24 >> 3 & 0x7) 
20184                                                     /* index at 24 */ < 8)) 
20185                                               goto MATCH_label_c175;  /*opt-block+*/
20186                                             else 
20187                                               goto MATCH_label_c174;  /*opt-block+*/
20188                                             
20189                                             break;
20190                                           case 5: 
20191                                             goto MATCH_label_c176; break;
20192                                           default: assert(0);
20193                                         } /* (MATCH_w_8_16 & 0x7) 
20194                                               -- r_m at 16 --*/ 
20195                                       break;
20196                                     case 1: 
20197                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20198                                       if ((MATCH_w_8_16 & 0x7) 
20199                                               /* r_m at 16 */ == 4 && 
20200                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20201                                               /* index at 24 */ && 
20202                                         (MATCH_w_8_24 >> 3 & 0x7) 
20203                                               /* index at 24 */ < 8)) { 
20204                                         unsigned Eaddr = 
20205                                           2 + addressToPC(MATCH_p);
20206                                         unsigned reg = 
20207                                           (MATCH_w_8_16 >> 3 & 0x7) 
20208                                                 /* reg_opcode at 16 */;
20209                                         nextPC = 5 + MATCH_p; 
20210                                         
20211 #line 1438 "frontend/machine/pentium/decoder.m"
20212                                         
20213 
20214                                                 stmts = instantiate(pc,  "ADCrmow", DIS_REG16, DIS_EADDR16);
20215 
20216                                         
20217 
20218                                         
20219                                         
20220                                         
20221                                       } /*opt-block*//*opt-block+*/
20222                                       else 
20223                                         goto MATCH_label_c174;  /*opt-block+*/
20224                                       
20225                                       break;
20226                                     case 2: 
20227                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20228                                       if ((MATCH_w_8_16 & 0x7) 
20229                                               /* r_m at 16 */ == 4 && 
20230                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20231                                               /* index at 24 */ && 
20232                                         (MATCH_w_8_24 >> 3 & 0x7) 
20233                                               /* index at 24 */ < 8)) 
20234                                         goto MATCH_label_c175;  /*opt-block+*/
20235                                       else 
20236                                         goto MATCH_label_c176;  /*opt-block+*/
20237                                       
20238                                       break;
20239                                     case 3: 
20240                                       goto MATCH_label_c173; break;
20241                                     default: assert(0);
20242                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
20243                                         -- mod at 16 --*/ 
20244                                 
20245                               } /*opt-block*/
20246                               break;
20247                             case 5: 
20248                               if ((MATCH_w_8_8 >> 3 & 0x1) 
20249                                       /* page at 8 */ == 1) { 
20250                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
20251                                 { 
20252                                   int /* [~32768..32767] */ i16 = 
20253                                     sign_extend((MATCH_w_16_16 & 0xffff) 
20254                                                       /* i16 at 16 */, 16);
20255                                   nextPC = 4 + MATCH_p; 
20256                                   
20257 #line 1708 "frontend/machine/pentium/decoder.m"
20258                                   
20259 
20260                                         stmts = instantiate(pc,  "SBBiAX", DIS_I16);
20261 
20262                                   
20263 
20264                                   
20265                                   
20266                                   
20267                                 }
20268                                 
20269                               } /*opt-block*/
20270                               else { 
20271                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
20272                                 { 
20273                                   int /* [~32768..32767] */ i16 = 
20274                                     sign_extend((MATCH_w_16_16 & 0xffff) 
20275                                                       /* i16 at 16 */, 16);
20276                                   nextPC = 4 + MATCH_p; 
20277                                   
20278 #line 1711 "frontend/machine/pentium/decoder.m"
20279                                   
20280 
20281                                         stmts = instantiate(pc,  "ADCiAX", DIS_I16);
20282 
20283                                   
20284 
20285                                   
20286                                   
20287                                   
20288                                 }
20289                                 
20290                               } /*opt-block*/
20291                               
20292                               break;
20293                             default: assert(0);
20294                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
20295                         break;
20296                       case 2: 
20297                         
20298                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
20299                             case 0: case 2: case 4: case 6: case 7: 
20300                               goto MATCH_label_c64; break;
20301                             case 1: 
20302                               if ((MATCH_w_8_8 >> 3 & 0x1) 
20303                                       /* page at 8 */ == 1) { 
20304                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
20305                                 
20306                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
20307                                         /* mod at 16 */) {
20308                                     case 0: 
20309                                       
20310                                         switch((MATCH_w_8_16 & 0x7) 
20311                                               /* r_m at 16 */) {
20312                                           case 0: case 1: case 2: case 3: 
20313                                           case 6: case 7: 
20314                                             goto MATCH_label_c185; break;
20315                                           case 4: 
20316                                             MATCH_w_8_24 = 
20317                                               getByte(3 + MATCH_p); 
20318                                             if ((MATCH_w_8_24 & 0x7) 
20319                                                     /* base at 24 */ == 5 && 
20320                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20321                                                     /* index at 24 */ && 
20322                                               (MATCH_w_8_24 >> 3 & 0x7) 
20323                                                     /* index at 24 */ < 8)) 
20324                                               goto MATCH_label_c187;  /*opt-block+*/
20325                                             else 
20326                                               goto MATCH_label_c186;  /*opt-block+*/
20327                                             
20328                                             break;
20329                                           case 5: 
20330                                             goto MATCH_label_c188; break;
20331                                           default: assert(0);
20332                                         } /* (MATCH_w_8_16 & 0x7) 
20333                                               -- r_m at 16 --*/ 
20334                                       break;
20335                                     case 1: 
20336                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20337                                       if ((MATCH_w_8_16 & 0x7) 
20338                                               /* r_m at 16 */ == 4 && 
20339                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20340                                               /* index at 24 */ && 
20341                                         (MATCH_w_8_24 >> 3 & 0x7) 
20342                                               /* index at 24 */ < 8)) { 
20343                                         unsigned Eaddr = 
20344                                           2 + addressToPC(MATCH_p);
20345                                         unsigned reg = 
20346                                           (MATCH_w_8_16 >> 3 & 0x7) 
20347                                                 /* reg_opcode at 16 */;
20348                                         nextPC = 5 + MATCH_p; 
20349                                         
20350 #line 1492 "frontend/machine/pentium/decoder.m"
20351                                         
20352 
20353                                                 stmts = instantiate(pc,  "SUBmrow", DIS_EADDR16, DIS_REG16);
20354 
20355                                         
20356 
20357                                         
20358                                         
20359                                         
20360                                       } /*opt-block*//*opt-block+*/
20361                                       else 
20362                                         goto MATCH_label_c186;  /*opt-block+*/
20363                                       
20364                                       break;
20365                                     case 2: 
20366                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20367                                       if ((MATCH_w_8_16 & 0x7) 
20368                                               /* r_m at 16 */ == 4 && 
20369                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20370                                               /* index at 24 */ && 
20371                                         (MATCH_w_8_24 >> 3 & 0x7) 
20372                                               /* index at 24 */ < 8)) 
20373                                         goto MATCH_label_c187;  /*opt-block+*/
20374                                       else 
20375                                         goto MATCH_label_c188;  /*opt-block+*/
20376                                       
20377                                       break;
20378                                     case 3: 
20379                                       goto MATCH_label_c185; break;
20380                                     default: assert(0);
20381                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
20382                                         -- mod at 16 --*/ 
20383                                 
20384                               } /*opt-block*/
20385                               else { 
20386                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
20387                                 
20388                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
20389                                         /* mod at 16 */) {
20390                                     case 0: 
20391                                       
20392                                         switch((MATCH_w_8_16 & 0x7) 
20393                                               /* r_m at 16 */) {
20394                                           case 0: case 1: case 2: case 3: 
20395                                           case 6: case 7: 
20396                                             goto MATCH_label_c181; break;
20397                                           case 4: 
20398                                             MATCH_w_8_24 = 
20399                                               getByte(3 + MATCH_p); 
20400                                             if ((MATCH_w_8_24 & 0x7) 
20401                                                     /* base at 24 */ == 5 && 
20402                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20403                                                     /* index at 24 */ && 
20404                                               (MATCH_w_8_24 >> 3 & 0x7) 
20405                                                     /* index at 24 */ < 8)) 
20406                                               goto MATCH_label_c183;  /*opt-block+*/
20407                                             else 
20408                                               goto MATCH_label_c182;  /*opt-block+*/
20409                                             
20410                                             break;
20411                                           case 5: 
20412                                             goto MATCH_label_c184; break;
20413                                           default: assert(0);
20414                                         } /* (MATCH_w_8_16 & 0x7) 
20415                                               -- r_m at 16 --*/ 
20416                                       break;
20417                                     case 1: 
20418                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20419                                       if ((MATCH_w_8_16 & 0x7) 
20420                                               /* r_m at 16 */ == 4 && 
20421                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20422                                               /* index at 24 */ && 
20423                                         (MATCH_w_8_24 >> 3 & 0x7) 
20424                                               /* index at 24 */ < 8)) { 
20425                                         unsigned Eaddr = 
20426                                           2 + addressToPC(MATCH_p);
20427                                         unsigned reg = 
20428                                           (MATCH_w_8_16 >> 3 & 0x7) 
20429                                                 /* reg_opcode at 16 */;
20430                                         nextPC = 5 + MATCH_p; 
20431                                         
20432 #line 1498 "frontend/machine/pentium/decoder.m"
20433                                         
20434 
20435                                                 stmts = instantiate(pc,  "ANDmrow", DIS_EADDR16, DIS_REG16);
20436 
20437                                         
20438 
20439                                         
20440                                         
20441                                         
20442                                       } /*opt-block*//*opt-block+*/
20443                                       else 
20444                                         goto MATCH_label_c182;  /*opt-block+*/
20445                                       
20446                                       break;
20447                                     case 2: 
20448                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20449                                       if ((MATCH_w_8_16 & 0x7) 
20450                                               /* r_m at 16 */ == 4 && 
20451                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20452                                               /* index at 24 */ && 
20453                                         (MATCH_w_8_24 >> 3 & 0x7) 
20454                                               /* index at 24 */ < 8)) 
20455                                         goto MATCH_label_c183;  /*opt-block+*/
20456                                       else 
20457                                         goto MATCH_label_c184;  /*opt-block+*/
20458                                       
20459                                       break;
20460                                     case 3: 
20461                                       goto MATCH_label_c181; break;
20462                                     default: assert(0);
20463                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
20464                                         -- mod at 16 --*/ 
20465                                 
20466                               } /*opt-block*/
20467                               break;
20468                             case 3: 
20469                               if ((MATCH_w_8_8 >> 3 & 0x1) 
20470                                       /* page at 8 */ == 1) { 
20471                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
20472                                 
20473                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
20474                                         /* mod at 16 */) {
20475                                     case 0: 
20476                                       
20477                                         switch((MATCH_w_8_16 & 0x7) 
20478                                               /* r_m at 16 */) {
20479                                           case 0: case 1: case 2: case 3: 
20480                                           case 6: case 7: 
20481                                             goto MATCH_label_c193; break;
20482                                           case 4: 
20483                                             MATCH_w_8_24 = 
20484                                               getByte(3 + MATCH_p); 
20485                                             if ((MATCH_w_8_24 & 0x7) 
20486                                                     /* base at 24 */ == 5 && 
20487                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20488                                                     /* index at 24 */ && 
20489                                               (MATCH_w_8_24 >> 3 & 0x7) 
20490                                                     /* index at 24 */ < 8)) 
20491                                               goto MATCH_label_c195;  /*opt-block+*/
20492                                             else 
20493                                               goto MATCH_label_c194;  /*opt-block+*/
20494                                             
20495                                             break;
20496                                           case 5: 
20497                                             goto MATCH_label_c196; break;
20498                                           default: assert(0);
20499                                         } /* (MATCH_w_8_16 & 0x7) 
20500                                               -- r_m at 16 --*/ 
20501                                       break;
20502                                     case 1: 
20503                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20504                                       if ((MATCH_w_8_16 & 0x7) 
20505                                               /* r_m at 16 */ == 4 && 
20506                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20507                                               /* index at 24 */ && 
20508                                         (MATCH_w_8_24 >> 3 & 0x7) 
20509                                               /* index at 24 */ < 8)) { 
20510                                         unsigned Eaddr = 
20511                                           2 + addressToPC(MATCH_p);
20512                                         unsigned reg = 
20513                                           (MATCH_w_8_16 >> 3 & 0x7) 
20514                                                 /* reg_opcode at 16 */;
20515                                         nextPC = 5 + MATCH_p; 
20516                                         
20517 #line 1420 "frontend/machine/pentium/decoder.m"
20518                                         
20519 
20520                                                 stmts = instantiate(pc,  "SUBrmow", DIS_REG16, DIS_EADDR16);
20521 
20522                                         
20523 
20524                                         
20525                                         
20526                                         
20527                                       } /*opt-block*//*opt-block+*/
20528                                       else 
20529                                         goto MATCH_label_c194;  /*opt-block+*/
20530                                       
20531                                       break;
20532                                     case 2: 
20533                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20534                                       if ((MATCH_w_8_16 & 0x7) 
20535                                               /* r_m at 16 */ == 4 && 
20536                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20537                                               /* index at 24 */ && 
20538                                         (MATCH_w_8_24 >> 3 & 0x7) 
20539                                               /* index at 24 */ < 8)) 
20540                                         goto MATCH_label_c195;  /*opt-block+*/
20541                                       else 
20542                                         goto MATCH_label_c196;  /*opt-block+*/
20543                                       
20544                                       break;
20545                                     case 3: 
20546                                       goto MATCH_label_c193; break;
20547                                     default: assert(0);
20548                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
20549                                         -- mod at 16 --*/ 
20550                                 
20551                               } /*opt-block*/
20552                               else { 
20553                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
20554                                 
20555                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
20556                                         /* mod at 16 */) {
20557                                     case 0: 
20558                                       
20559                                         switch((MATCH_w_8_16 & 0x7) 
20560                                               /* r_m at 16 */) {
20561                                           case 0: case 1: case 2: case 3: 
20562                                           case 6: case 7: 
20563                                             goto MATCH_label_c189; break;
20564                                           case 4: 
20565                                             MATCH_w_8_24 = 
20566                                               getByte(3 + MATCH_p); 
20567                                             if ((MATCH_w_8_24 & 0x7) 
20568                                                     /* base at 24 */ == 5 && 
20569                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20570                                                     /* index at 24 */ && 
20571                                               (MATCH_w_8_24 >> 3 & 0x7) 
20572                                                     /* index at 24 */ < 8)) 
20573                                               goto MATCH_label_c191;  /*opt-block+*/
20574                                             else 
20575                                               goto MATCH_label_c190;  /*opt-block+*/
20576                                             
20577                                             break;
20578                                           case 5: 
20579                                             goto MATCH_label_c192; break;
20580                                           default: assert(0);
20581                                         } /* (MATCH_w_8_16 & 0x7) 
20582                                               -- r_m at 16 --*/ 
20583                                       break;
20584                                     case 1: 
20585                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20586                                       if ((MATCH_w_8_16 & 0x7) 
20587                                               /* r_m at 16 */ == 4 && 
20588                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20589                                               /* index at 24 */ && 
20590                                         (MATCH_w_8_24 >> 3 & 0x7) 
20591                                               /* index at 24 */ < 8)) { 
20592                                         unsigned Eaddr = 
20593                                           2 + addressToPC(MATCH_p);
20594                                         unsigned reg = 
20595                                           (MATCH_w_8_16 >> 3 & 0x7) 
20596                                                 /* reg_opcode at 16 */;
20597                                         nextPC = 5 + MATCH_p; 
20598                                         
20599 #line 1426 "frontend/machine/pentium/decoder.m"
20600                                         
20601 
20602                                                 stmts = instantiate(pc,  "ANDrmow", DIS_REG16, DIS_EADDR16);
20603 
20604                                         
20605 
20606                                         
20607                                         
20608                                         
20609                                       } /*opt-block*//*opt-block+*/
20610                                       else 
20611                                         goto MATCH_label_c190;  /*opt-block+*/
20612                                       
20613                                       break;
20614                                     case 2: 
20615                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20616                                       if ((MATCH_w_8_16 & 0x7) 
20617                                               /* r_m at 16 */ == 4 && 
20618                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20619                                               /* index at 24 */ && 
20620                                         (MATCH_w_8_24 >> 3 & 0x7) 
20621                                               /* index at 24 */ < 8)) 
20622                                         goto MATCH_label_c191;  /*opt-block+*/
20623                                       else 
20624                                         goto MATCH_label_c192;  /*opt-block+*/
20625                                       
20626                                       break;
20627                                     case 3: 
20628                                       goto MATCH_label_c189; break;
20629                                     default: assert(0);
20630                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
20631                                         -- mod at 16 --*/ 
20632                                 
20633                               } /*opt-block*/
20634                               break;
20635                             case 5: 
20636                               if ((MATCH_w_8_8 >> 3 & 0x1) 
20637                                       /* page at 8 */ == 1) { 
20638                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
20639                                 { 
20640                                   int /* [~32768..32767] */ i16 = 
20641                                     sign_extend((MATCH_w_16_16 & 0xffff) 
20642                                                       /* i16 at 16 */, 16);
20643                                   nextPC = 4 + MATCH_p; 
20644                                   
20645 #line 1702 "frontend/machine/pentium/decoder.m"
20646                                   
20647 
20648                                         stmts = instantiate(pc,  "SUBiAX", DIS_I16);
20649 
20650                                   
20651 
20652                                   
20653                                   
20654                                   
20655                                 }
20656                                 
20657                               } /*opt-block*/
20658                               else { 
20659                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
20660                                 { 
20661                                   int /* [~32768..32767] */ i16 = 
20662                                     sign_extend((MATCH_w_16_16 & 0xffff) 
20663                                                       /* i16 at 16 */, 16);
20664                                   nextPC = 4 + MATCH_p; 
20665                                   
20666 #line 1705 "frontend/machine/pentium/decoder.m"
20667                                   
20668 
20669                                         stmts = instantiate(pc,  "ANDiAX", DIS_I16);
20670 
20671                                   
20672 
20673                                   
20674                                   
20675                                   
20676                                 }
20677                                 
20678                               } /*opt-block*/
20679                               
20680                               break;
20681                             default: assert(0);
20682                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
20683                         break;
20684                       case 3: 
20685                         
20686                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
20687                             case 0: case 2: case 4: case 6: case 7: 
20688                               goto MATCH_label_c64; break;
20689                             case 1: 
20690                               if ((MATCH_w_8_8 >> 3 & 0x1) 
20691                                       /* page at 8 */ == 1) { 
20692                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
20693                                 
20694                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
20695                                         /* mod at 16 */) {
20696                                     case 0: 
20697                                       
20698                                         switch((MATCH_w_8_16 & 0x7) 
20699                                               /* r_m at 16 */) {
20700                                           case 0: case 1: case 2: case 3: 
20701                                           case 6: case 7: 
20702                                             goto MATCH_label_c201; break;
20703                                           case 4: 
20704                                             MATCH_w_8_24 = 
20705                                               getByte(3 + MATCH_p); 
20706                                             if ((MATCH_w_8_24 & 0x7) 
20707                                                     /* base at 24 */ == 5 && 
20708                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20709                                                     /* index at 24 */ && 
20710                                               (MATCH_w_8_24 >> 3 & 0x7) 
20711                                                     /* index at 24 */ < 8)) 
20712                                               goto MATCH_label_c203;  /*opt-block+*/
20713                                             else 
20714                                               goto MATCH_label_c202;  /*opt-block+*/
20715                                             
20716                                             break;
20717                                           case 5: 
20718                                             goto MATCH_label_c204; break;
20719                                           default: assert(0);
20720                                         } /* (MATCH_w_8_16 & 0x7) 
20721                                               -- r_m at 16 --*/ 
20722                                       break;
20723                                     case 1: 
20724                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20725                                       if ((MATCH_w_8_16 & 0x7) 
20726                                               /* r_m at 16 */ == 4 && 
20727                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20728                                               /* index at 24 */ && 
20729                                         (MATCH_w_8_24 >> 3 & 0x7) 
20730                                               /* index at 24 */ < 8)) { 
20731                                         unsigned Eaddr = 
20732                                           2 + addressToPC(MATCH_p);
20733                                         unsigned reg = 
20734                                           (MATCH_w_8_16 >> 3 & 0x7) 
20735                                                 /* reg_opcode at 16 */;
20736                                         nextPC = 5 + MATCH_p; 
20737                                         
20738 #line 1480 "frontend/machine/pentium/decoder.m"
20739                                         
20740 
20741                                                 stmts = instantiate(pc,  "CMPmrow", DIS_EADDR16, DIS_REG16);
20742 
20743                                         
20744 
20745                                         
20746                                         
20747                                         
20748                                       } /*opt-block*//*opt-block+*/
20749                                       else 
20750                                         goto MATCH_label_c202;  /*opt-block+*/
20751                                       
20752                                       break;
20753                                     case 2: 
20754                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20755                                       if ((MATCH_w_8_16 & 0x7) 
20756                                               /* r_m at 16 */ == 4 && 
20757                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20758                                               /* index at 24 */ && 
20759                                         (MATCH_w_8_24 >> 3 & 0x7) 
20760                                               /* index at 24 */ < 8)) 
20761                                         goto MATCH_label_c203;  /*opt-block+*/
20762                                       else 
20763                                         goto MATCH_label_c204;  /*opt-block+*/
20764                                       
20765                                       break;
20766                                     case 3: 
20767                                       goto MATCH_label_c201; break;
20768                                     default: assert(0);
20769                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
20770                                         -- mod at 16 --*/ 
20771                                 
20772                               } /*opt-block*/
20773                               else { 
20774                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
20775                                 
20776                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
20777                                         /* mod at 16 */) {
20778                                     case 0: 
20779                                       
20780                                         switch((MATCH_w_8_16 & 0x7) 
20781                                               /* r_m at 16 */) {
20782                                           case 0: case 1: case 2: case 3: 
20783                                           case 6: case 7: 
20784                                             goto MATCH_label_c197; break;
20785                                           case 4: 
20786                                             MATCH_w_8_24 = 
20787                                               getByte(3 + MATCH_p); 
20788                                             if ((MATCH_w_8_24 & 0x7) 
20789                                                     /* base at 24 */ == 5 && 
20790                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20791                                                     /* index at 24 */ && 
20792                                               (MATCH_w_8_24 >> 3 & 0x7) 
20793                                                     /* index at 24 */ < 8)) 
20794                                               goto MATCH_label_c199;  /*opt-block+*/
20795                                             else 
20796                                               goto MATCH_label_c198;  /*opt-block+*/
20797                                             
20798                                             break;
20799                                           case 5: 
20800                                             goto MATCH_label_c200; break;
20801                                           default: assert(0);
20802                                         } /* (MATCH_w_8_16 & 0x7) 
20803                                               -- r_m at 16 --*/ 
20804                                       break;
20805                                     case 1: 
20806                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20807                                       if ((MATCH_w_8_16 & 0x7) 
20808                                               /* r_m at 16 */ == 4 && 
20809                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20810                                               /* index at 24 */ && 
20811                                         (MATCH_w_8_24 >> 3 & 0x7) 
20812                                               /* index at 24 */ < 8)) { 
20813                                         unsigned Eaddr = 
20814                                           2 + addressToPC(MATCH_p);
20815                                         unsigned reg = 
20816                                           (MATCH_w_8_16 >> 3 & 0x7) 
20817                                                 /* reg_opcode at 16 */;
20818                                         nextPC = 5 + MATCH_p; 
20819                                         
20820 #line 1486 "frontend/machine/pentium/decoder.m"
20821                                         
20822 
20823                                                 stmts = instantiate(pc,  "XORmrow", DIS_EADDR16, DIS_REG16);
20824 
20825                                         
20826 
20827                                         
20828                                         
20829                                         
20830                                       } /*opt-block*//*opt-block+*/
20831                                       else 
20832                                         goto MATCH_label_c198;  /*opt-block+*/
20833                                       
20834                                       break;
20835                                     case 2: 
20836                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20837                                       if ((MATCH_w_8_16 & 0x7) 
20838                                               /* r_m at 16 */ == 4 && 
20839                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20840                                               /* index at 24 */ && 
20841                                         (MATCH_w_8_24 >> 3 & 0x7) 
20842                                               /* index at 24 */ < 8)) 
20843                                         goto MATCH_label_c199;  /*opt-block+*/
20844                                       else 
20845                                         goto MATCH_label_c200;  /*opt-block+*/
20846                                       
20847                                       break;
20848                                     case 3: 
20849                                       goto MATCH_label_c197; break;
20850                                     default: assert(0);
20851                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
20852                                         -- mod at 16 --*/ 
20853                                 
20854                               } /*opt-block*/
20855                               break;
20856                             case 3: 
20857                               if ((MATCH_w_8_8 >> 3 & 0x1) 
20858                                       /* page at 8 */ == 1) { 
20859                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
20860                                 
20861                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
20862                                         /* mod at 16 */) {
20863                                     case 0: 
20864                                       
20865                                         switch((MATCH_w_8_16 & 0x7) 
20866                                               /* r_m at 16 */) {
20867                                           case 0: case 1: case 2: case 3: 
20868                                           case 6: case 7: 
20869                                             goto MATCH_label_c209; break;
20870                                           case 4: 
20871                                             MATCH_w_8_24 = 
20872                                               getByte(3 + MATCH_p); 
20873                                             if ((MATCH_w_8_24 & 0x7) 
20874                                                     /* base at 24 */ == 5 && 
20875                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20876                                                     /* index at 24 */ && 
20877                                               (MATCH_w_8_24 >> 3 & 0x7) 
20878                                                     /* index at 24 */ < 8)) 
20879                                               goto MATCH_label_c211;  /*opt-block+*/
20880                                             else 
20881                                               goto MATCH_label_c210;  /*opt-block+*/
20882                                             
20883                                             break;
20884                                           case 5: 
20885                                             goto MATCH_label_c212; break;
20886                                           default: assert(0);
20887                                         } /* (MATCH_w_8_16 & 0x7) 
20888                                               -- r_m at 16 --*/ 
20889                                       break;
20890                                     case 1: 
20891                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20892                                       if ((MATCH_w_8_16 & 0x7) 
20893                                               /* r_m at 16 */ == 4 && 
20894                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20895                                               /* index at 24 */ && 
20896                                         (MATCH_w_8_24 >> 3 & 0x7) 
20897                                               /* index at 24 */ < 8)) { 
20898                                         unsigned Eaddr = 
20899                                           2 + addressToPC(MATCH_p);
20900                                         unsigned reg = 
20901                                           (MATCH_w_8_16 >> 3 & 0x7) 
20902                                                 /* reg_opcode at 16 */;
20903                                         nextPC = 5 + MATCH_p; 
20904                                         
20905 #line 1408 "frontend/machine/pentium/decoder.m"
20906                                         
20907 
20908                                                 stmts = instantiate(pc,  "CMPrmow", DIS_REG16, DIS_EADDR16);
20909 
20910                                         
20911 
20912                                         
20913                                         
20914                                         
20915                                       } /*opt-block*//*opt-block+*/
20916                                       else 
20917                                         goto MATCH_label_c210;  /*opt-block+*/
20918                                       
20919                                       break;
20920                                     case 2: 
20921                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20922                                       if ((MATCH_w_8_16 & 0x7) 
20923                                               /* r_m at 16 */ == 4 && 
20924                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20925                                               /* index at 24 */ && 
20926                                         (MATCH_w_8_24 >> 3 & 0x7) 
20927                                               /* index at 24 */ < 8)) 
20928                                         goto MATCH_label_c211;  /*opt-block+*/
20929                                       else 
20930                                         goto MATCH_label_c212;  /*opt-block+*/
20931                                       
20932                                       break;
20933                                     case 3: 
20934                                       goto MATCH_label_c209; break;
20935                                     default: assert(0);
20936                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
20937                                         -- mod at 16 --*/ 
20938                                 
20939                               } /*opt-block*/
20940                               else { 
20941                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
20942                                 
20943                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
20944                                         /* mod at 16 */) {
20945                                     case 0: 
20946                                       
20947                                         switch((MATCH_w_8_16 & 0x7) 
20948                                               /* r_m at 16 */) {
20949                                           case 0: case 1: case 2: case 3: 
20950                                           case 6: case 7: 
20951                                             goto MATCH_label_c205; break;
20952                                           case 4: 
20953                                             MATCH_w_8_24 = 
20954                                               getByte(3 + MATCH_p); 
20955                                             if ((MATCH_w_8_24 & 0x7) 
20956                                                     /* base at 24 */ == 5 && 
20957                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20958                                                     /* index at 24 */ && 
20959                                               (MATCH_w_8_24 >> 3 & 0x7) 
20960                                                     /* index at 24 */ < 8)) 
20961                                               goto MATCH_label_c207;  /*opt-block+*/
20962                                             else 
20963                                               goto MATCH_label_c206;  /*opt-block+*/
20964                                             
20965                                             break;
20966                                           case 5: 
20967                                             goto MATCH_label_c208; break;
20968                                           default: assert(0);
20969                                         } /* (MATCH_w_8_16 & 0x7) 
20970                                               -- r_m at 16 --*/ 
20971                                       break;
20972                                     case 1: 
20973                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20974                                       if ((MATCH_w_8_16 & 0x7) 
20975                                               /* r_m at 16 */ == 4 && 
20976                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
20977                                               /* index at 24 */ && 
20978                                         (MATCH_w_8_24 >> 3 & 0x7) 
20979                                               /* index at 24 */ < 8)) { 
20980                                         unsigned Eaddr = 
20981                                           2 + addressToPC(MATCH_p);
20982                                         unsigned reg = 
20983                                           (MATCH_w_8_16 >> 3 & 0x7) 
20984                                                 /* reg_opcode at 16 */;
20985                                         nextPC = 5 + MATCH_p; 
20986                                         
20987 #line 1414 "frontend/machine/pentium/decoder.m"
20988                                         
20989 
20990                                                 stmts = instantiate(pc,  "XORrmow", DIS_REG16, DIS_EADDR16);
20991 
20992                                         
20993 
20994                                         
20995                                         
20996                                         
20997                                       } /*opt-block*//*opt-block+*/
20998                                       else 
20999                                         goto MATCH_label_c206;  /*opt-block+*/
21000                                       
21001                                       break;
21002                                     case 2: 
21003                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
21004                                       if ((MATCH_w_8_16 & 0x7) 
21005                                               /* r_m at 16 */ == 4 && 
21006                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21007                                               /* index at 24 */ && 
21008                                         (MATCH_w_8_24 >> 3 & 0x7) 
21009                                               /* index at 24 */ < 8)) 
21010                                         goto MATCH_label_c207;  /*opt-block+*/
21011                                       else 
21012                                         goto MATCH_label_c208;  /*opt-block+*/
21013                                       
21014                                       break;
21015                                     case 3: 
21016                                       goto MATCH_label_c205; break;
21017                                     default: assert(0);
21018                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
21019                                         -- mod at 16 --*/ 
21020                                 
21021                               } /*opt-block*/
21022                               break;
21023                             case 5: 
21024                               if ((MATCH_w_8_8 >> 3 & 0x1) 
21025                                       /* page at 8 */ == 1) { 
21026                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
21027                                 { 
21028                                   int /* [~32768..32767] */ i16 = 
21029                                     sign_extend((MATCH_w_16_16 & 0xffff) 
21030                                                       /* i16 at 16 */, 16);
21031                                   nextPC = 4 + MATCH_p; 
21032                                   
21033 #line 1696 "frontend/machine/pentium/decoder.m"
21034                                   
21035 
21036                                         stmts = instantiate(pc,  "CMPiAX", DIS_I16);
21037 
21038                                   
21039 
21040                                   
21041                                   
21042                                   
21043                                 }
21044                                 
21045                               } /*opt-block*/
21046                               else { 
21047                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
21048                                 { 
21049                                   int /* [~32768..32767] */ i16 = 
21050                                     sign_extend((MATCH_w_16_16 & 0xffff) 
21051                                                       /* i16 at 16 */, 16);
21052                                   nextPC = 4 + MATCH_p; 
21053                                   
21054 #line 1699 "frontend/machine/pentium/decoder.m"
21055                                   
21056 
21057                                         stmts = instantiate(pc,  "XORiAX", DIS_I16);
21058 
21059                                   
21060 
21061                                   
21062                                   
21063                                   
21064                                 }
21065                                 
21066                               } /*opt-block*/
21067                               
21068                               break;
21069                             default: assert(0);
21070                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
21071                         break;
21072                       case 4: 
21073                         if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) { 
21074                           unsigned r32 = (MATCH_w_8_8 & 0x7) /* r32 at 8 */;
21075                           nextPC = 2 + MATCH_p; 
21076                           
21077 #line 1208 "frontend/machine/pentium/decoder.m"
21078                           
21079 
21080                                 stmts = instantiate(pc,  "DECow", DIS_R32);
21081 
21082                           
21083 
21084                           
21085                           
21086                           
21087                         } /*opt-block*//*opt-block+*/
21088                         else { 
21089                           unsigned r32 = (MATCH_w_8_8 & 0x7) /* r32 at 8 */;
21090                           nextPC = 2 + MATCH_p; 
21091                           
21092 #line 1124 "frontend/machine/pentium/decoder.m"
21093                           
21094 
21095                                 stmts = instantiate(pc,  "INCow", DIS_R32);
21096 
21097                           
21098 
21099                           
21100                           
21101                           
21102                         } /*opt-block*//*opt-block+*/
21103                         
21104                         break;
21105                       case 5: 
21106                         if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) { 
21107                           unsigned r32 = (MATCH_w_8_8 & 0x7) /* r32 at 8 */;
21108                           nextPC = 2 + MATCH_p; 
21109                           
21110 #line 874 "frontend/machine/pentium/decoder.m"
21111                           
21112 
21113                                 stmts = instantiate(pc,  "POPow", DIS_R32);   // Check!
21114 
21115                           
21116 
21117                           
21118                           
21119                           
21120                         } /*opt-block*//*opt-block+*/
21121                         else { 
21122                           unsigned r32 = (MATCH_w_8_8 & 0x7) /* r32 at 8 */;
21123                           nextPC = 2 + MATCH_p; 
21124                           
21125 #line 835 "frontend/machine/pentium/decoder.m"
21126                           
21127 
21128                                 stmts = instantiate(pc,  "PUSHow", DIS_R32);  // Check!
21129 
21130                           
21131 
21132                           
21133                           
21134                           
21135                         } /*opt-block*//*opt-block+*/
21136                         
21137                         break;
21138                       case 6: 
21139                         if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) 
21140                           
21141                             switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
21142                               case 0: 
21143                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
21144                                 { 
21145                                   int /* [~32768..32767] */ i16 = 
21146                                     sign_extend((MATCH_w_16_16 & 0xffff) 
21147                                                       /* i16 at 16 */, 16);
21148                                   nextPC = 4 + MATCH_p; 
21149                                   
21150 #line 823 "frontend/machine/pentium/decoder.m"
21151                                   
21152 
21153                                         stmts = instantiate(pc,  "PUSH.Ivow", DIS_I16);
21154 
21155                                   
21156 
21157                                   
21158                                   
21159                                   
21160                                 }
21161                                 
21162                                 break;
21163                               case 1: 
21164                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
21165                                 
21166                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
21167                                         /* mod at 16 */) {
21168                                     case 0: 
21169                                       
21170                                         switch((MATCH_w_8_16 & 0x7) 
21171                                               /* r_m at 16 */) {
21172                                           case 0: case 1: case 2: case 3: 
21173                                           case 6: case 7: 
21174                                             MATCH_w_16_24 = 
21175                                               getWord(3 + MATCH_p); 
21176                                             goto MATCH_label_c213; 
21177                                             
21178                                             break;
21179                                           case 4: 
21180                                             MATCH_w_8_24 = 
21181                                               getByte(3 + MATCH_p); 
21182                                             if ((MATCH_w_8_24 & 0x7) 
21183                                                     /* base at 24 */ == 5 && 
21184                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21185                                                     /* index at 24 */ && 
21186                                               (MATCH_w_8_24 >> 3 & 0x7) 
21187                                                     /* index at 24 */ < 8)) { 
21188                                               MATCH_w_16_64 = 
21189                                                 getWord(8 + MATCH_p); 
21190                                               goto MATCH_label_c215; 
21191                                               
21192                                             } /*opt-block*/
21193                                             else { 
21194                                               MATCH_w_16_32 = 
21195                                                 getWord(4 + MATCH_p); 
21196                                               goto MATCH_label_c214; 
21197                                               
21198                                             } /*opt-block*/
21199                                             
21200                                             break;
21201                                           case 5: 
21202                                             MATCH_w_16_56 = 
21203                                               getWord(7 + MATCH_p); 
21204                                             goto MATCH_label_c216; 
21205                                             
21206                                             break;
21207                                           default: assert(0);
21208                                         } /* (MATCH_w_8_16 & 0x7) 
21209                                               -- r_m at 16 --*/ 
21210                                       break;
21211                                     case 1: 
21212                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
21213                                       if ((MATCH_w_8_16 & 0x7) 
21214                                               /* r_m at 16 */ == 4 && 
21215                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21216                                               /* index at 24 */ && 
21217                                         (MATCH_w_8_24 >> 3 & 0x7) 
21218                                               /* index at 24 */ < 8)) { 
21219                                         MATCH_w_16_40 = getWord(5 + MATCH_p); 
21220                                         { 
21221                                           unsigned Eaddr = 
21222                                             2 + addressToPC(MATCH_p);
21223                                           int /* [~32768..32767] */ i16 = 
21224                                             sign_extend((MATCH_w_16_40 & 0xffff) 
21225                                                               /* i16 at 40 */, 
21226                                                         16);
21227                                           unsigned reg = 
21228                                             (MATCH_w_8_16 >> 3 & 0x7) 
21229                                                   /* reg_opcode at 16 */;
21230                                           nextPC = 7 + MATCH_p; 
21231                                           
21232 #line 1157 "frontend/machine/pentium/decoder.m"
21233                                           
21234 
21235                                                 stmts = instantiate(pc,  "IMUL.Ivw", DIS_REG16, DIS_EADDR16, DIS_I16);
21236 
21237                                           
21238 
21239                                           
21240                                           
21241                                           
21242                                         }
21243                                         
21244                                       } /*opt-block*/
21245                                       else { 
21246                                         MATCH_w_16_32 = getWord(4 + MATCH_p); 
21247                                         goto MATCH_label_c214; 
21248                                         
21249                                       } /*opt-block*/
21250                                       
21251                                       break;
21252                                     case 2: 
21253                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
21254                                       if ((MATCH_w_8_16 & 0x7) 
21255                                               /* r_m at 16 */ == 4 && 
21256                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21257                                               /* index at 24 */ && 
21258                                         (MATCH_w_8_24 >> 3 & 0x7) 
21259                                               /* index at 24 */ < 8)) { 
21260                                         MATCH_w_16_64 = getWord(8 + MATCH_p); 
21261                                         goto MATCH_label_c215; 
21262                                         
21263                                       } /*opt-block*/
21264                                       else { 
21265                                         MATCH_w_16_56 = getWord(7 + MATCH_p); 
21266                                         goto MATCH_label_c216; 
21267                                         
21268                                       } /*opt-block*/
21269                                       
21270                                       break;
21271                                     case 3: 
21272                                       MATCH_w_16_24 = getWord(3 + MATCH_p); 
21273                                       goto MATCH_label_c213; 
21274                                       
21275                                       break;
21276                                     default: assert(0);
21277                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
21278                                         -- mod at 16 --*/ 
21279                                 
21280                                 break;
21281                               case 2: 
21282                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
21283                                 { 
21284                                   int /* [~128..127] */ i8 = 
21285                                     sign_extend((MATCH_w_8_16 & 0xff) 
21286                                                       /* i8 at 16 */, 8);
21287                                   nextPC = 3 + MATCH_p; 
21288                                   
21289 #line 829 "frontend/machine/pentium/decoder.m"
21290                                   
21291 
21292                                         stmts = instantiate(pc,  "PUSH.Ixow", DIS_I8);
21293 
21294                                   
21295 
21296                                   
21297                                   
21298                                   
21299                                 }
21300                                 
21301                                 break;
21302                               case 3: 
21303                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
21304                                 
21305                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
21306                                         /* mod at 16 */) {
21307                                     case 0: 
21308                                       
21309                                         switch((MATCH_w_8_16 & 0x7) 
21310                                               /* r_m at 16 */) {
21311                                           case 0: case 1: case 2: case 3: 
21312                                           case 6: case 7: 
21313                                             MATCH_w_8_24 = 
21314                                               getByte(3 + MATCH_p); 
21315                                             goto MATCH_label_c217; 
21316                                             
21317                                             break;
21318                                           case 4: 
21319                                             MATCH_w_8_24 = 
21320                                               getByte(3 + MATCH_p); 
21321                                             if ((MATCH_w_8_24 & 0x7) 
21322                                                     /* base at 24 */ == 5 && 
21323                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21324                                                     /* index at 24 */ && 
21325                                               (MATCH_w_8_24 >> 3 & 0x7) 
21326                                                     /* index at 24 */ < 8)) { 
21327                                               MATCH_w_8_64 = 
21328                                                 getByte(8 + MATCH_p); 
21329                                               goto MATCH_label_c219; 
21330                                               
21331                                             } /*opt-block*/
21332                                             else { 
21333                                               MATCH_w_8_32 = 
21334                                                 getByte(4 + MATCH_p); 
21335                                               goto MATCH_label_c218; 
21336                                               
21337                                             } /*opt-block*/
21338                                             
21339                                             break;
21340                                           case 5: 
21341                                             MATCH_w_8_56 = 
21342                                               getByte(7 + MATCH_p); 
21343                                             goto MATCH_label_c220; 
21344                                             
21345                                             break;
21346                                           default: assert(0);
21347                                         } /* (MATCH_w_8_16 & 0x7) 
21348                                               -- r_m at 16 --*/ 
21349                                       break;
21350                                     case 1: 
21351                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
21352                                       if ((MATCH_w_8_16 & 0x7) 
21353                                               /* r_m at 16 */ == 4 && 
21354                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21355                                               /* index at 24 */ && 
21356                                         (MATCH_w_8_24 >> 3 & 0x7) 
21357                                               /* index at 24 */ < 8)) { 
21358                                         MATCH_w_8_40 = getByte(5 + MATCH_p); 
21359                                         { 
21360                                           unsigned Eaddr = 
21361                                             2 + addressToPC(MATCH_p);
21362                                           int /* [~128..127] */ i8 = 
21363                                             sign_extend((MATCH_w_8_40 & 0xff) 
21364                                                               /* i8 at 40 */, 
21365                                                         8);
21366                                           unsigned reg = 
21367                                             (MATCH_w_8_16 >> 3 & 0x7) 
21368                                                   /* reg_opcode at 16 */;
21369                                           nextPC = 6 + MATCH_p; 
21370                                           
21371 #line 1163 "frontend/machine/pentium/decoder.m"
21372                                           
21373 
21374                                                 stmts = instantiate(pc,  "IMUL.Ibow", DIS_REG16, DIS_EADDR16, DIS_I8);
21375 
21376                                           
21377 
21378                                           
21379                                           
21380                                           
21381                                         }
21382                                         
21383                                       } /*opt-block*/
21384                                       else { 
21385                                         MATCH_w_8_32 = getByte(4 + MATCH_p); 
21386                                         goto MATCH_label_c218; 
21387                                         
21388                                       } /*opt-block*/
21389                                       
21390                                       break;
21391                                     case 2: 
21392                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
21393                                       if ((MATCH_w_8_16 & 0x7) 
21394                                               /* r_m at 16 */ == 4 && 
21395                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21396                                               /* index at 24 */ && 
21397                                         (MATCH_w_8_24 >> 3 & 0x7) 
21398                                               /* index at 24 */ < 8)) { 
21399                                         MATCH_w_8_64 = getByte(8 + MATCH_p); 
21400                                         goto MATCH_label_c219; 
21401                                         
21402                                       } /*opt-block*/
21403                                       else { 
21404                                         MATCH_w_8_56 = getByte(7 + MATCH_p); 
21405                                         goto MATCH_label_c220; 
21406                                         
21407                                       } /*opt-block*/
21408                                       
21409                                       break;
21410                                     case 3: 
21411                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
21412                                       goto MATCH_label_c217; 
21413                                       
21414                                       break;
21415                                     default: assert(0);
21416                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
21417                                         -- mod at 16 --*/ 
21418                                 
21419                                 break;
21420                               case 4: case 5: case 6: case 7: 
21421                                 goto MATCH_label_c64; break;
21422                               default: assert(0);
21423                             } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/  
21424                         else 
21425                           goto MATCH_label_c64;  /*opt-block+*/
21426                         break;
21427                       case 7: 
21428                         goto MATCH_label_c64; break;
21429                       case 8: 
21430                         
21431                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
21432                             case 0: case 2: case 4: case 6: 
21433                               goto MATCH_label_c64; break;
21434                             case 1: 
21435                               if ((MATCH_w_8_8 >> 3 & 0x1) 
21436                                       /* page at 8 */ == 1) { 
21437                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
21438                                 
21439                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
21440                                         /* mod at 16 */) {
21441                                     case 0: 
21442                                       
21443                                         switch((MATCH_w_8_16 & 0x7) 
21444                                               /* r_m at 16 */) {
21445                                           case 0: case 1: case 2: case 3: 
21446                                           case 6: case 7: 
21447                                             goto MATCH_label_c253; break;
21448                                           case 4: 
21449                                             MATCH_w_8_24 = 
21450                                               getByte(3 + MATCH_p); 
21451                                             if ((MATCH_w_8_24 & 0x7) 
21452                                                     /* base at 24 */ == 5 && 
21453                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21454                                                     /* index at 24 */ && 
21455                                               (MATCH_w_8_24 >> 3 & 0x7) 
21456                                                     /* index at 24 */ < 8)) 
21457                                               goto MATCH_label_c255;  /*opt-block+*/
21458                                             else 
21459                                               goto MATCH_label_c254;  /*opt-block+*/
21460                                             
21461                                             break;
21462                                           case 5: 
21463                                             goto MATCH_label_c256; break;
21464                                           default: assert(0);
21465                                         } /* (MATCH_w_8_16 & 0x7) 
21466                                               -- r_m at 16 --*/ 
21467                                       break;
21468                                     case 1: 
21469                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
21470                                       if ((MATCH_w_8_16 & 0x7) 
21471                                               /* r_m at 16 */ == 4 && 
21472                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21473                                               /* index at 24 */ && 
21474                                         (MATCH_w_8_24 >> 3 & 0x7) 
21475                                               /* index at 24 */ < 8)) { 
21476                                         unsigned Eaddr = 
21477                                           2 + addressToPC(MATCH_p);
21478                                         unsigned reg = 
21479                                           (MATCH_w_8_16 >> 3 & 0x7) 
21480                                                 /* reg_opcode at 16 */;
21481                                         nextPC = 5 + MATCH_p; 
21482                                         
21483 #line 1034 "frontend/machine/pentium/decoder.m"
21484                                         
21485 
21486                                                 stmts = instantiate(pc,  "MOVmrow", DIS_EADDR16, DIS_REG16);
21487 
21488                                         
21489 
21490                                         
21491                                         
21492                                         
21493                                       } /*opt-block*//*opt-block+*/
21494                                       else 
21495                                         goto MATCH_label_c254;  /*opt-block+*/
21496                                       
21497                                       break;
21498                                     case 2: 
21499                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
21500                                       if ((MATCH_w_8_16 & 0x7) 
21501                                               /* r_m at 16 */ == 4 && 
21502                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21503                                               /* index at 24 */ && 
21504                                         (MATCH_w_8_24 >> 3 & 0x7) 
21505                                               /* index at 24 */ < 8)) 
21506                                         goto MATCH_label_c255;  /*opt-block+*/
21507                                       else 
21508                                         goto MATCH_label_c256;  /*opt-block+*/
21509                                       
21510                                       break;
21511                                     case 3: 
21512                                       goto MATCH_label_c253; break;
21513                                     default: assert(0);
21514                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
21515                                         -- mod at 16 --*/ 
21516                                 
21517                               } /*opt-block*/
21518                               else { 
21519                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
21520                                 
21521                                   switch((MATCH_w_8_16 >> 3 & 0x7) 
21522                                         /* reg_opcode at 16 */) {
21523                                     case 0: 
21524                                       
21525                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
21526                                               /* mod at 16 */) {
21527                                           case 0: 
21528                                             
21529                                               switch((MATCH_w_8_16 & 0x7) 
21530                                                     /* r_m at 16 */) {
21531                                                 case 0: case 1: case 2: 
21532                                                 case 3: case 6: case 7: 
21533                                                   MATCH_w_16_24 = 
21534                                                     getWord(3 + MATCH_p); 
21535                                                   goto MATCH_label_c221; 
21536                                                   
21537                                                   break;
21538                                                 case 4: 
21539                                                   MATCH_w_8_24 = 
21540                                                     getByte(3 + MATCH_p); 
21541                                                   if ((MATCH_w_8_24 & 0x7) 
21542                                                           /* base at 24 */ == 5 && 
21543                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21544                                                           /* index at 24 */ && 
21545                                                     (MATCH_w_8_24 >> 3 & 0x7) 
21546                                                           /* index at 24 */ < 8)) { 
21547                                                     MATCH_w_16_64 = 
21548                                                       getWord(8 + MATCH_p); 
21549                                                     goto MATCH_label_c223; 
21550                                                     
21551                                                   } /*opt-block*/
21552                                                   else { 
21553                                                     MATCH_w_16_32 = 
21554                                                       getWord(4 + MATCH_p); 
21555                                                     goto MATCH_label_c222; 
21556                                                     
21557                                                   } /*opt-block*/
21558                                                   
21559                                                   break;
21560                                                 case 5: 
21561                                                   MATCH_w_16_56 = 
21562                                                     getWord(7 + MATCH_p); 
21563                                                   goto MATCH_label_c224; 
21564                                                   
21565                                                   break;
21566                                                 default: assert(0);
21567                                               } /* (MATCH_w_8_16 & 0x7) 
21568                                                     -- r_m at 16 --*/ 
21569                                             break;
21570                                           case 1: 
21571                                             MATCH_w_8_24 = 
21572                                               getByte(3 + MATCH_p); 
21573                                             if ((MATCH_w_8_16 & 0x7) 
21574                                                     /* r_m at 16 */ == 4 && 
21575                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21576                                                     /* index at 24 */ && 
21577                                               (MATCH_w_8_24 >> 3 & 0x7) 
21578                                                     /* index at 24 */ < 8)) { 
21579                                               MATCH_w_16_40 = 
21580                                                 getWord(5 + MATCH_p); 
21581                                               { 
21582                                                 unsigned Eaddr = 
21583                                                   2 + addressToPC(MATCH_p);
21584                                                 int /* [~32768..32767] */ i16 = 
21585                                                   sign_extend((MATCH_w_16_40 & 0xffff) 
21586                                                                     /* i16 at 40 */, 
21587                                                               16);
21588                                                 nextPC = 7 + MATCH_p; 
21589                                                 
21590 #line 1645 "frontend/machine/pentium/decoder.m"
21591                                                 
21592 
21593                                                         stmts = instantiate(pc,  "ADDiw", DIS_EADDR16, DIS_I16);
21594 
21595                                                 
21596 
21597                                                 
21598                                                 
21599                                                 
21600                                               }
21601                                               
21602                                             } /*opt-block*/
21603                                             else { 
21604                                               MATCH_w_16_32 = 
21605                                                 getWord(4 + MATCH_p); 
21606                                               goto MATCH_label_c222; 
21607                                               
21608                                             } /*opt-block*/
21609                                             
21610                                             break;
21611                                           case 2: 
21612                                             MATCH_w_8_24 = 
21613                                               getByte(3 + MATCH_p); 
21614                                             if ((MATCH_w_8_16 & 0x7) 
21615                                                     /* r_m at 16 */ == 4 && 
21616                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21617                                                     /* index at 24 */ && 
21618                                               (MATCH_w_8_24 >> 3 & 0x7) 
21619                                                     /* index at 24 */ < 8)) { 
21620                                               MATCH_w_16_64 = 
21621                                                 getWord(8 + MATCH_p); 
21622                                               goto MATCH_label_c223; 
21623                                               
21624                                             } /*opt-block*/
21625                                             else { 
21626                                               MATCH_w_16_56 = 
21627                                                 getWord(7 + MATCH_p); 
21628                                               goto MATCH_label_c224; 
21629                                               
21630                                             } /*opt-block*/
21631                                             
21632                                             break;
21633                                           case 3: 
21634                                             MATCH_w_16_24 = 
21635                                               getWord(3 + MATCH_p); 
21636                                             goto MATCH_label_c221; 
21637                                             
21638                                             break;
21639                                           default: assert(0);
21640                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
21641                                               -- mod at 16 --*/ 
21642                                       break;
21643                                     case 1: 
21644                                       
21645                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
21646                                               /* mod at 16 */) {
21647                                           case 0: 
21648                                             
21649                                               switch((MATCH_w_8_16 & 0x7) 
21650                                                     /* r_m at 16 */) {
21651                                                 case 0: case 1: case 2: 
21652                                                 case 3: case 6: case 7: 
21653                                                   MATCH_w_16_24 = 
21654                                                     getWord(3 + MATCH_p); 
21655                                                   goto MATCH_label_c225; 
21656                                                   
21657                                                   break;
21658                                                 case 4: 
21659                                                   MATCH_w_8_24 = 
21660                                                     getByte(3 + MATCH_p); 
21661                                                   if ((MATCH_w_8_24 & 0x7) 
21662                                                           /* base at 24 */ == 5 && 
21663                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21664                                                           /* index at 24 */ && 
21665                                                     (MATCH_w_8_24 >> 3 & 0x7) 
21666                                                           /* index at 24 */ < 8)) { 
21667                                                     MATCH_w_16_64 = 
21668                                                       getWord(8 + MATCH_p); 
21669                                                     goto MATCH_label_c227; 
21670                                                     
21671                                                   } /*opt-block*/
21672                                                   else { 
21673                                                     MATCH_w_16_32 = 
21674                                                       getWord(4 + MATCH_p); 
21675                                                     goto MATCH_label_c226; 
21676                                                     
21677                                                   } /*opt-block*/
21678                                                   
21679                                                   break;
21680                                                 case 5: 
21681                                                   MATCH_w_16_56 = 
21682                                                     getWord(7 + MATCH_p); 
21683                                                   goto MATCH_label_c228; 
21684                                                   
21685                                                   break;
21686                                                 default: assert(0);
21687                                               } /* (MATCH_w_8_16 & 0x7) 
21688                                                     -- r_m at 16 --*/ 
21689                                             break;
21690                                           case 1: 
21691                                             MATCH_w_8_24 = 
21692                                               getByte(3 + MATCH_p); 
21693                                             if ((MATCH_w_8_16 & 0x7) 
21694                                                     /* r_m at 16 */ == 4 && 
21695                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21696                                                     /* index at 24 */ && 
21697                                               (MATCH_w_8_24 >> 3 & 0x7) 
21698                                                     /* index at 24 */ < 8)) { 
21699                                               MATCH_w_16_40 = 
21700                                                 getWord(5 + MATCH_p); 
21701                                               { 
21702                                                 unsigned Eaddr = 
21703                                                   2 + addressToPC(MATCH_p);
21704                                                 int /* [~32768..32767] */ i16 = 
21705                                                   sign_extend((MATCH_w_16_40 & 0xffff) 
21706                                                                     /* i16 at 40 */, 
21707                                                               16);
21708                                                 nextPC = 7 + MATCH_p; 
21709                                                 
21710 #line 1642 "frontend/machine/pentium/decoder.m"
21711                                                 
21712 
21713                                                         stmts = instantiate(pc,  "ORiw", DIS_EADDR16, DIS_I16);
21714 
21715                                                 
21716 
21717                                                 
21718                                                 
21719                                                 
21720                                               }
21721                                               
21722                                             } /*opt-block*/
21723                                             else { 
21724                                               MATCH_w_16_32 = 
21725                                                 getWord(4 + MATCH_p); 
21726                                               goto MATCH_label_c226; 
21727                                               
21728                                             } /*opt-block*/
21729                                             
21730                                             break;
21731                                           case 2: 
21732                                             MATCH_w_8_24 = 
21733                                               getByte(3 + MATCH_p); 
21734                                             if ((MATCH_w_8_16 & 0x7) 
21735                                                     /* r_m at 16 */ == 4 && 
21736                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21737                                                     /* index at 24 */ && 
21738                                               (MATCH_w_8_24 >> 3 & 0x7) 
21739                                                     /* index at 24 */ < 8)) { 
21740                                               MATCH_w_16_64 = 
21741                                                 getWord(8 + MATCH_p); 
21742                                               goto MATCH_label_c227; 
21743                                               
21744                                             } /*opt-block*/
21745                                             else { 
21746                                               MATCH_w_16_56 = 
21747                                                 getWord(7 + MATCH_p); 
21748                                               goto MATCH_label_c228; 
21749                                               
21750                                             } /*opt-block*/
21751                                             
21752                                             break;
21753                                           case 3: 
21754                                             MATCH_w_16_24 = 
21755                                               getWord(3 + MATCH_p); 
21756                                             goto MATCH_label_c225; 
21757                                             
21758                                             break;
21759                                           default: assert(0);
21760                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
21761                                               -- mod at 16 --*/ 
21762                                       break;
21763                                     case 2: 
21764                                       
21765                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
21766                                               /* mod at 16 */) {
21767                                           case 0: 
21768                                             
21769                                               switch((MATCH_w_8_16 & 0x7) 
21770                                                     /* r_m at 16 */) {
21771                                                 case 0: case 1: case 2: 
21772                                                 case 3: case 6: case 7: 
21773                                                   MATCH_w_16_24 = 
21774                                                     getWord(3 + MATCH_p); 
21775                                                   goto MATCH_label_c229; 
21776                                                   
21777                                                   break;
21778                                                 case 4: 
21779                                                   MATCH_w_8_24 = 
21780                                                     getByte(3 + MATCH_p); 
21781                                                   if ((MATCH_w_8_24 & 0x7) 
21782                                                           /* base at 24 */ == 5 && 
21783                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21784                                                           /* index at 24 */ && 
21785                                                     (MATCH_w_8_24 >> 3 & 0x7) 
21786                                                           /* index at 24 */ < 8)) { 
21787                                                     MATCH_w_16_64 = 
21788                                                       getWord(8 + MATCH_p); 
21789                                                     goto MATCH_label_c231; 
21790                                                     
21791                                                   } /*opt-block*/
21792                                                   else { 
21793                                                     MATCH_w_16_32 = 
21794                                                       getWord(4 + MATCH_p); 
21795                                                     goto MATCH_label_c230; 
21796                                                     
21797                                                   } /*opt-block*/
21798                                                   
21799                                                   break;
21800                                                 case 5: 
21801                                                   MATCH_w_16_56 = 
21802                                                     getWord(7 + MATCH_p); 
21803                                                   goto MATCH_label_c232; 
21804                                                   
21805                                                   break;
21806                                                 default: assert(0);
21807                                               } /* (MATCH_w_8_16 & 0x7) 
21808                                                     -- r_m at 16 --*/ 
21809                                             break;
21810                                           case 1: 
21811                                             MATCH_w_8_24 = 
21812                                               getByte(3 + MATCH_p); 
21813                                             if ((MATCH_w_8_16 & 0x7) 
21814                                                     /* r_m at 16 */ == 4 && 
21815                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21816                                                     /* index at 24 */ && 
21817                                               (MATCH_w_8_24 >> 3 & 0x7) 
21818                                                     /* index at 24 */ < 8)) { 
21819                                               MATCH_w_16_40 = 
21820                                                 getWord(5 + MATCH_p); 
21821                                               { 
21822                                                 unsigned Eaddr = 
21823                                                   2 + addressToPC(MATCH_p);
21824                                                 int /* [~32768..32767] */ i16 = 
21825                                                   sign_extend((MATCH_w_16_40 & 0xffff) 
21826                                                                     /* i16 at 40 */, 
21827                                                               16);
21828                                                 nextPC = 7 + MATCH_p; 
21829                                                 
21830 #line 1639 "frontend/machine/pentium/decoder.m"
21831                                                 
21832 
21833                                                         stmts = instantiate(pc,  "ADCiw", DIS_EADDR16, DIS_I16);
21834 
21835                                                 
21836 
21837                                                 
21838                                                 
21839                                                 
21840                                               }
21841                                               
21842                                             } /*opt-block*/
21843                                             else { 
21844                                               MATCH_w_16_32 = 
21845                                                 getWord(4 + MATCH_p); 
21846                                               goto MATCH_label_c230; 
21847                                               
21848                                             } /*opt-block*/
21849                                             
21850                                             break;
21851                                           case 2: 
21852                                             MATCH_w_8_24 = 
21853                                               getByte(3 + MATCH_p); 
21854                                             if ((MATCH_w_8_16 & 0x7) 
21855                                                     /* r_m at 16 */ == 4 && 
21856                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21857                                                     /* index at 24 */ && 
21858                                               (MATCH_w_8_24 >> 3 & 0x7) 
21859                                                     /* index at 24 */ < 8)) { 
21860                                               MATCH_w_16_64 = 
21861                                                 getWord(8 + MATCH_p); 
21862                                               goto MATCH_label_c231; 
21863                                               
21864                                             } /*opt-block*/
21865                                             else { 
21866                                               MATCH_w_16_56 = 
21867                                                 getWord(7 + MATCH_p); 
21868                                               goto MATCH_label_c232; 
21869                                               
21870                                             } /*opt-block*/
21871                                             
21872                                             break;
21873                                           case 3: 
21874                                             MATCH_w_16_24 = 
21875                                               getWord(3 + MATCH_p); 
21876                                             goto MATCH_label_c229; 
21877                                             
21878                                             break;
21879                                           default: assert(0);
21880                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
21881                                               -- mod at 16 --*/ 
21882                                       break;
21883                                     case 3: 
21884                                       
21885                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
21886                                               /* mod at 16 */) {
21887                                           case 0: 
21888                                             
21889                                               switch((MATCH_w_8_16 & 0x7) 
21890                                                     /* r_m at 16 */) {
21891                                                 case 0: case 1: case 2: 
21892                                                 case 3: case 6: case 7: 
21893                                                   MATCH_w_16_24 = 
21894                                                     getWord(3 + MATCH_p); 
21895                                                   goto MATCH_label_c233; 
21896                                                   
21897                                                   break;
21898                                                 case 4: 
21899                                                   MATCH_w_8_24 = 
21900                                                     getByte(3 + MATCH_p); 
21901                                                   if ((MATCH_w_8_24 & 0x7) 
21902                                                           /* base at 24 */ == 5 && 
21903                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21904                                                           /* index at 24 */ && 
21905                                                     (MATCH_w_8_24 >> 3 & 0x7) 
21906                                                           /* index at 24 */ < 8)) { 
21907                                                     MATCH_w_16_64 = 
21908                                                       getWord(8 + MATCH_p); 
21909                                                     goto MATCH_label_c235; 
21910                                                     
21911                                                   } /*opt-block*/
21912                                                   else { 
21913                                                     MATCH_w_16_32 = 
21914                                                       getWord(4 + MATCH_p); 
21915                                                     goto MATCH_label_c234; 
21916                                                     
21917                                                   } /*opt-block*/
21918                                                   
21919                                                   break;
21920                                                 case 5: 
21921                                                   MATCH_w_16_56 = 
21922                                                     getWord(7 + MATCH_p); 
21923                                                   goto MATCH_label_c236; 
21924                                                   
21925                                                   break;
21926                                                 default: assert(0);
21927                                               } /* (MATCH_w_8_16 & 0x7) 
21928                                                     -- r_m at 16 --*/ 
21929                                             break;
21930                                           case 1: 
21931                                             MATCH_w_8_24 = 
21932                                               getByte(3 + MATCH_p); 
21933                                             if ((MATCH_w_8_16 & 0x7) 
21934                                                     /* r_m at 16 */ == 4 && 
21935                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21936                                                     /* index at 24 */ && 
21937                                               (MATCH_w_8_24 >> 3 & 0x7) 
21938                                                     /* index at 24 */ < 8)) { 
21939                                               MATCH_w_16_40 = 
21940                                                 getWord(5 + MATCH_p); 
21941                                               { 
21942                                                 unsigned Eaddr = 
21943                                                   2 + addressToPC(MATCH_p);
21944                                                 int /* [~32768..32767] */ i16 = 
21945                                                   sign_extend((MATCH_w_16_40 & 0xffff) 
21946                                                                     /* i16 at 40 */, 
21947                                                               16);
21948                                                 nextPC = 7 + MATCH_p; 
21949                                                 
21950 #line 1636 "frontend/machine/pentium/decoder.m"
21951                                                 
21952 
21953                                                         stmts = instantiate(pc,  "SBBiw", DIS_EADDR16, DIS_I16);
21954 
21955                                                 
21956 
21957                                                 
21958                                                 
21959                                                 
21960                                               }
21961                                               
21962                                             } /*opt-block*/
21963                                             else { 
21964                                               MATCH_w_16_32 = 
21965                                                 getWord(4 + MATCH_p); 
21966                                               goto MATCH_label_c234; 
21967                                               
21968                                             } /*opt-block*/
21969                                             
21970                                             break;
21971                                           case 2: 
21972                                             MATCH_w_8_24 = 
21973                                               getByte(3 + MATCH_p); 
21974                                             if ((MATCH_w_8_16 & 0x7) 
21975                                                     /* r_m at 16 */ == 4 && 
21976                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
21977                                                     /* index at 24 */ && 
21978                                               (MATCH_w_8_24 >> 3 & 0x7) 
21979                                                     /* index at 24 */ < 8)) { 
21980                                               MATCH_w_16_64 = 
21981                                                 getWord(8 + MATCH_p); 
21982                                               goto MATCH_label_c235; 
21983                                               
21984                                             } /*opt-block*/
21985                                             else { 
21986                                               MATCH_w_16_56 = 
21987                                                 getWord(7 + MATCH_p); 
21988                                               goto MATCH_label_c236; 
21989                                               
21990                                             } /*opt-block*/
21991                                             
21992                                             break;
21993                                           case 3: 
21994                                             MATCH_w_16_24 = 
21995                                               getWord(3 + MATCH_p); 
21996                                             goto MATCH_label_c233; 
21997                                             
21998                                             break;
21999                                           default: assert(0);
22000                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
22001                                               -- mod at 16 --*/ 
22002                                       break;
22003                                     case 4: 
22004                                       
22005                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
22006                                               /* mod at 16 */) {
22007                                           case 0: 
22008                                             
22009                                               switch((MATCH_w_8_16 & 0x7) 
22010                                                     /* r_m at 16 */) {
22011                                                 case 0: case 1: case 2: 
22012                                                 case 3: case 6: case 7: 
22013                                                   MATCH_w_16_24 = 
22014                                                     getWord(3 + MATCH_p); 
22015                                                   goto MATCH_label_c237; 
22016                                                   
22017                                                   break;
22018                                                 case 4: 
22019                                                   MATCH_w_8_24 = 
22020                                                     getByte(3 + MATCH_p); 
22021                                                   if ((MATCH_w_8_24 & 0x7) 
22022                                                           /* base at 24 */ == 5 && 
22023                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22024                                                           /* index at 24 */ && 
22025                                                     (MATCH_w_8_24 >> 3 & 0x7) 
22026                                                           /* index at 24 */ < 8)) { 
22027                                                     MATCH_w_16_64 = 
22028                                                       getWord(8 + MATCH_p); 
22029                                                     goto MATCH_label_c239; 
22030                                                     
22031                                                   } /*opt-block*/
22032                                                   else { 
22033                                                     MATCH_w_16_32 = 
22034                                                       getWord(4 + MATCH_p); 
22035                                                     goto MATCH_label_c238; 
22036                                                     
22037                                                   } /*opt-block*/
22038                                                   
22039                                                   break;
22040                                                 case 5: 
22041                                                   MATCH_w_16_56 = 
22042                                                     getWord(7 + MATCH_p); 
22043                                                   goto MATCH_label_c240; 
22044                                                   
22045                                                   break;
22046                                                 default: assert(0);
22047                                               } /* (MATCH_w_8_16 & 0x7) 
22048                                                     -- r_m at 16 --*/ 
22049                                             break;
22050                                           case 1: 
22051                                             MATCH_w_8_24 = 
22052                                               getByte(3 + MATCH_p); 
22053                                             if ((MATCH_w_8_16 & 0x7) 
22054                                                     /* r_m at 16 */ == 4 && 
22055                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22056                                                     /* index at 24 */ && 
22057                                               (MATCH_w_8_24 >> 3 & 0x7) 
22058                                                     /* index at 24 */ < 8)) { 
22059                                               MATCH_w_16_40 = 
22060                                                 getWord(5 + MATCH_p); 
22061                                               { 
22062                                                 unsigned Eaddr = 
22063                                                   2 + addressToPC(MATCH_p);
22064                                                 int /* [~32768..32767] */ i16 = 
22065                                                   sign_extend((MATCH_w_16_40 & 0xffff) 
22066                                                                     /* i16 at 40 */, 
22067                                                               16);
22068                                                 nextPC = 7 + MATCH_p; 
22069                                                 
22070 #line 1633 "frontend/machine/pentium/decoder.m"
22071                                                 
22072 
22073                                                         stmts = instantiate(pc,  "ANDiw", DIS_EADDR16, DIS_I16);
22074 
22075                                                 
22076 
22077                                                 
22078                                                 
22079                                                 
22080                                               }
22081                                               
22082                                             } /*opt-block*/
22083                                             else { 
22084                                               MATCH_w_16_32 = 
22085                                                 getWord(4 + MATCH_p); 
22086                                               goto MATCH_label_c238; 
22087                                               
22088                                             } /*opt-block*/
22089                                             
22090                                             break;
22091                                           case 2: 
22092                                             MATCH_w_8_24 = 
22093                                               getByte(3 + MATCH_p); 
22094                                             if ((MATCH_w_8_16 & 0x7) 
22095                                                     /* r_m at 16 */ == 4 && 
22096                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22097                                                     /* index at 24 */ && 
22098                                               (MATCH_w_8_24 >> 3 & 0x7) 
22099                                                     /* index at 24 */ < 8)) { 
22100                                               MATCH_w_16_64 = 
22101                                                 getWord(8 + MATCH_p); 
22102                                               goto MATCH_label_c239; 
22103                                               
22104                                             } /*opt-block*/
22105                                             else { 
22106                                               MATCH_w_16_56 = 
22107                                                 getWord(7 + MATCH_p); 
22108                                               goto MATCH_label_c240; 
22109                                               
22110                                             } /*opt-block*/
22111                                             
22112                                             break;
22113                                           case 3: 
22114                                             MATCH_w_16_24 = 
22115                                               getWord(3 + MATCH_p); 
22116                                             goto MATCH_label_c237; 
22117                                             
22118                                             break;
22119                                           default: assert(0);
22120                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
22121                                               -- mod at 16 --*/ 
22122                                       break;
22123                                     case 5: 
22124                                       
22125                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
22126                                               /* mod at 16 */) {
22127                                           case 0: 
22128                                             
22129                                               switch((MATCH_w_8_16 & 0x7) 
22130                                                     /* r_m at 16 */) {
22131                                                 case 0: case 1: case 2: 
22132                                                 case 3: case 6: case 7: 
22133                                                   MATCH_w_16_24 = 
22134                                                     getWord(3 + MATCH_p); 
22135                                                   goto MATCH_label_c241; 
22136                                                   
22137                                                   break;
22138                                                 case 4: 
22139                                                   MATCH_w_8_24 = 
22140                                                     getByte(3 + MATCH_p); 
22141                                                   if ((MATCH_w_8_24 & 0x7) 
22142                                                           /* base at 24 */ == 5 && 
22143                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22144                                                           /* index at 24 */ && 
22145                                                     (MATCH_w_8_24 >> 3 & 0x7) 
22146                                                           /* index at 24 */ < 8)) { 
22147                                                     MATCH_w_16_64 = 
22148                                                       getWord(8 + MATCH_p); 
22149                                                     goto MATCH_label_c243; 
22150                                                     
22151                                                   } /*opt-block*/
22152                                                   else { 
22153                                                     MATCH_w_16_32 = 
22154                                                       getWord(4 + MATCH_p); 
22155                                                     goto MATCH_label_c242; 
22156                                                     
22157                                                   } /*opt-block*/
22158                                                   
22159                                                   break;
22160                                                 case 5: 
22161                                                   MATCH_w_16_56 = 
22162                                                     getWord(7 + MATCH_p); 
22163                                                   goto MATCH_label_c244; 
22164                                                   
22165                                                   break;
22166                                                 default: assert(0);
22167                                               } /* (MATCH_w_8_16 & 0x7) 
22168                                                     -- r_m at 16 --*/ 
22169                                             break;
22170                                           case 1: 
22171                                             MATCH_w_8_24 = 
22172                                               getByte(3 + MATCH_p); 
22173                                             if ((MATCH_w_8_16 & 0x7) 
22174                                                     /* r_m at 16 */ == 4 && 
22175                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22176                                                     /* index at 24 */ && 
22177                                               (MATCH_w_8_24 >> 3 & 0x7) 
22178                                                     /* index at 24 */ < 8)) { 
22179                                               MATCH_w_16_40 = 
22180                                                 getWord(5 + MATCH_p); 
22181                                               { 
22182                                                 unsigned Eaddr = 
22183                                                   2 + addressToPC(MATCH_p);
22184                                                 int /* [~32768..32767] */ i16 = 
22185                                                   sign_extend((MATCH_w_16_40 & 0xffff) 
22186                                                                     /* i16 at 40 */, 
22187                                                               16);
22188                                                 nextPC = 7 + MATCH_p; 
22189                                                 
22190 #line 1630 "frontend/machine/pentium/decoder.m"
22191                                                 
22192 
22193                                                         stmts = instantiate(pc,  "SUBiw", DIS_EADDR16, DIS_I16);
22194 
22195                                                 
22196 
22197                                                 
22198                                                 
22199                                                 
22200                                               }
22201                                               
22202                                             } /*opt-block*/
22203                                             else { 
22204                                               MATCH_w_16_32 = 
22205                                                 getWord(4 + MATCH_p); 
22206                                               goto MATCH_label_c242; 
22207                                               
22208                                             } /*opt-block*/
22209                                             
22210                                             break;
22211                                           case 2: 
22212                                             MATCH_w_8_24 = 
22213                                               getByte(3 + MATCH_p); 
22214                                             if ((MATCH_w_8_16 & 0x7) 
22215                                                     /* r_m at 16 */ == 4 && 
22216                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22217                                                     /* index at 24 */ && 
22218                                               (MATCH_w_8_24 >> 3 & 0x7) 
22219                                                     /* index at 24 */ < 8)) { 
22220                                               MATCH_w_16_64 = 
22221                                                 getWord(8 + MATCH_p); 
22222                                               goto MATCH_label_c243; 
22223                                               
22224                                             } /*opt-block*/
22225                                             else { 
22226                                               MATCH_w_16_56 = 
22227                                                 getWord(7 + MATCH_p); 
22228                                               goto MATCH_label_c244; 
22229                                               
22230                                             } /*opt-block*/
22231                                             
22232                                             break;
22233                                           case 3: 
22234                                             MATCH_w_16_24 = 
22235                                               getWord(3 + MATCH_p); 
22236                                             goto MATCH_label_c241; 
22237                                             
22238                                             break;
22239                                           default: assert(0);
22240                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
22241                                               -- mod at 16 --*/ 
22242                                       break;
22243                                     case 6: 
22244                                       
22245                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
22246                                               /* mod at 16 */) {
22247                                           case 0: 
22248                                             
22249                                               switch((MATCH_w_8_16 & 0x7) 
22250                                                     /* r_m at 16 */) {
22251                                                 case 0: case 1: case 2: 
22252                                                 case 3: case 6: case 7: 
22253                                                   MATCH_w_16_24 = 
22254                                                     getWord(3 + MATCH_p); 
22255                                                   goto MATCH_label_c245; 
22256                                                   
22257                                                   break;
22258                                                 case 4: 
22259                                                   MATCH_w_8_24 = 
22260                                                     getByte(3 + MATCH_p); 
22261                                                   if ((MATCH_w_8_24 & 0x7) 
22262                                                           /* base at 24 */ == 5 && 
22263                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22264                                                           /* index at 24 */ && 
22265                                                     (MATCH_w_8_24 >> 3 & 0x7) 
22266                                                           /* index at 24 */ < 8)) { 
22267                                                     MATCH_w_16_64 = 
22268                                                       getWord(8 + MATCH_p); 
22269                                                     goto MATCH_label_c247; 
22270                                                     
22271                                                   } /*opt-block*/
22272                                                   else { 
22273                                                     MATCH_w_16_32 = 
22274                                                       getWord(4 + MATCH_p); 
22275                                                     goto MATCH_label_c246; 
22276                                                     
22277                                                   } /*opt-block*/
22278                                                   
22279                                                   break;
22280                                                 case 5: 
22281                                                   MATCH_w_16_56 = 
22282                                                     getWord(7 + MATCH_p); 
22283                                                   goto MATCH_label_c248; 
22284                                                   
22285                                                   break;
22286                                                 default: assert(0);
22287                                               } /* (MATCH_w_8_16 & 0x7) 
22288                                                     -- r_m at 16 --*/ 
22289                                             break;
22290                                           case 1: 
22291                                             MATCH_w_8_24 = 
22292                                               getByte(3 + MATCH_p); 
22293                                             if ((MATCH_w_8_16 & 0x7) 
22294                                                     /* r_m at 16 */ == 4 && 
22295                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22296                                                     /* index at 24 */ && 
22297                                               (MATCH_w_8_24 >> 3 & 0x7) 
22298                                                     /* index at 24 */ < 8)) { 
22299                                               MATCH_w_16_40 = 
22300                                                 getWord(5 + MATCH_p); 
22301                                               { 
22302                                                 unsigned Eaddr = 
22303                                                   2 + addressToPC(MATCH_p);
22304                                                 int /* [~32768..32767] */ i16 = 
22305                                                   sign_extend((MATCH_w_16_40 & 0xffff) 
22306                                                                     /* i16 at 40 */, 
22307                                                               16);
22308                                                 nextPC = 7 + MATCH_p; 
22309                                                 
22310 #line 1627 "frontend/machine/pentium/decoder.m"
22311                                                 
22312 
22313                                                         stmts = instantiate(pc,  "XORiw", DIS_EADDR16, DIS_I16);
22314 
22315                                                 
22316 
22317                                                 
22318                                                 
22319                                                 
22320                                               }
22321                                               
22322                                             } /*opt-block*/
22323                                             else { 
22324                                               MATCH_w_16_32 = 
22325                                                 getWord(4 + MATCH_p); 
22326                                               goto MATCH_label_c246; 
22327                                               
22328                                             } /*opt-block*/
22329                                             
22330                                             break;
22331                                           case 2: 
22332                                             MATCH_w_8_24 = 
22333                                               getByte(3 + MATCH_p); 
22334                                             if ((MATCH_w_8_16 & 0x7) 
22335                                                     /* r_m at 16 */ == 4 && 
22336                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22337                                                     /* index at 24 */ && 
22338                                               (MATCH_w_8_24 >> 3 & 0x7) 
22339                                                     /* index at 24 */ < 8)) { 
22340                                               MATCH_w_16_64 = 
22341                                                 getWord(8 + MATCH_p); 
22342                                               goto MATCH_label_c247; 
22343                                               
22344                                             } /*opt-block*/
22345                                             else { 
22346                                               MATCH_w_16_56 = 
22347                                                 getWord(7 + MATCH_p); 
22348                                               goto MATCH_label_c248; 
22349                                               
22350                                             } /*opt-block*/
22351                                             
22352                                             break;
22353                                           case 3: 
22354                                             MATCH_w_16_24 = 
22355                                               getWord(3 + MATCH_p); 
22356                                             goto MATCH_label_c245; 
22357                                             
22358                                             break;
22359                                           default: assert(0);
22360                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
22361                                               -- mod at 16 --*/ 
22362                                       break;
22363                                     case 7: 
22364                                       
22365                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
22366                                               /* mod at 16 */) {
22367                                           case 0: 
22368                                             
22369                                               switch((MATCH_w_8_16 & 0x7) 
22370                                                     /* r_m at 16 */) {
22371                                                 case 0: case 1: case 2: 
22372                                                 case 3: case 6: case 7: 
22373                                                   MATCH_w_16_24 = 
22374                                                     getWord(3 + MATCH_p); 
22375                                                   goto MATCH_label_c249; 
22376                                                   
22377                                                   break;
22378                                                 case 4: 
22379                                                   MATCH_w_8_24 = 
22380                                                     getByte(3 + MATCH_p); 
22381                                                   if ((MATCH_w_8_24 & 0x7) 
22382                                                           /* base at 24 */ == 5 && 
22383                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22384                                                           /* index at 24 */ && 
22385                                                     (MATCH_w_8_24 >> 3 & 0x7) 
22386                                                           /* index at 24 */ < 8)) { 
22387                                                     MATCH_w_16_64 = 
22388                                                       getWord(8 + MATCH_p); 
22389                                                     goto MATCH_label_c251; 
22390                                                     
22391                                                   } /*opt-block*/
22392                                                   else { 
22393                                                     MATCH_w_16_32 = 
22394                                                       getWord(4 + MATCH_p); 
22395                                                     goto MATCH_label_c250; 
22396                                                     
22397                                                   } /*opt-block*/
22398                                                   
22399                                                   break;
22400                                                 case 5: 
22401                                                   MATCH_w_16_56 = 
22402                                                     getWord(7 + MATCH_p); 
22403                                                   goto MATCH_label_c252; 
22404                                                   
22405                                                   break;
22406                                                 default: assert(0);
22407                                               } /* (MATCH_w_8_16 & 0x7) 
22408                                                     -- r_m at 16 --*/ 
22409                                             break;
22410                                           case 1: 
22411                                             MATCH_w_8_24 = 
22412                                               getByte(3 + MATCH_p); 
22413                                             if ((MATCH_w_8_16 & 0x7) 
22414                                                     /* r_m at 16 */ == 4 && 
22415                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22416                                                     /* index at 24 */ && 
22417                                               (MATCH_w_8_24 >> 3 & 0x7) 
22418                                                     /* index at 24 */ < 8)) { 
22419                                               MATCH_w_16_40 = 
22420                                                 getWord(5 + MATCH_p); 
22421                                               { 
22422                                                 unsigned Eaddr = 
22423                                                   2 + addressToPC(MATCH_p);
22424                                                 int /* [~32768..32767] */ i16 = 
22425                                                   sign_extend((MATCH_w_16_40 & 0xffff) 
22426                                                                     /* i16 at 40 */, 
22427                                                               16);
22428                                                 nextPC = 7 + MATCH_p; 
22429                                                 
22430 #line 1624 "frontend/machine/pentium/decoder.m"
22431                                                 
22432 
22433                                                         stmts = instantiate(pc,  "CMPiw", DIS_EADDR16, DIS_I16);
22434 
22435                                                 
22436 
22437                                                 
22438                                                 
22439                                                 
22440                                               }
22441                                               
22442                                             } /*opt-block*/
22443                                             else { 
22444                                               MATCH_w_16_32 = 
22445                                                 getWord(4 + MATCH_p); 
22446                                               goto MATCH_label_c250; 
22447                                               
22448                                             } /*opt-block*/
22449                                             
22450                                             break;
22451                                           case 2: 
22452                                             MATCH_w_8_24 = 
22453                                               getByte(3 + MATCH_p); 
22454                                             if ((MATCH_w_8_16 & 0x7) 
22455                                                     /* r_m at 16 */ == 4 && 
22456                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22457                                                     /* index at 24 */ && 
22458                                               (MATCH_w_8_24 >> 3 & 0x7) 
22459                                                     /* index at 24 */ < 8)) { 
22460                                               MATCH_w_16_64 = 
22461                                                 getWord(8 + MATCH_p); 
22462                                               goto MATCH_label_c251; 
22463                                               
22464                                             } /*opt-block*/
22465                                             else { 
22466                                               MATCH_w_16_56 = 
22467                                                 getWord(7 + MATCH_p); 
22468                                               goto MATCH_label_c252; 
22469                                               
22470                                             } /*opt-block*/
22471                                             
22472                                             break;
22473                                           case 3: 
22474                                             MATCH_w_16_24 = 
22475                                               getWord(3 + MATCH_p); 
22476                                             goto MATCH_label_c249; 
22477                                             
22478                                             break;
22479                                           default: assert(0);
22480                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
22481                                               -- mod at 16 --*/ 
22482                                       break;
22483                                     default: assert(0);
22484                                   } /* (MATCH_w_8_16 >> 3 & 0x7) 
22485                                         -- reg_opcode at 16 --*/ 
22486                                 
22487                               } /*opt-block*/
22488                               break;
22489                             case 3: 
22490                               if ((MATCH_w_8_8 >> 3 & 0x1) 
22491                                       /* page at 8 */ == 1) { 
22492                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
22493                                 
22494                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
22495                                         /* mod at 16 */) {
22496                                     case 0: 
22497                                       
22498                                         switch((MATCH_w_8_16 & 0x7) 
22499                                               /* r_m at 16 */) {
22500                                           case 0: case 1: case 2: case 3: 
22501                                           case 6: case 7: 
22502                                             goto MATCH_label_c289; break;
22503                                           case 4: 
22504                                             MATCH_w_8_24 = 
22505                                               getByte(3 + MATCH_p); 
22506                                             if ((MATCH_w_8_24 & 0x7) 
22507                                                     /* base at 24 */ == 5 && 
22508                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22509                                                     /* index at 24 */ && 
22510                                               (MATCH_w_8_24 >> 3 & 0x7) 
22511                                                     /* index at 24 */ < 8)) 
22512                                               goto MATCH_label_c291;  /*opt-block+*/
22513                                             else 
22514                                               goto MATCH_label_c290;  /*opt-block+*/
22515                                             
22516                                             break;
22517                                           case 5: 
22518                                             goto MATCH_label_c292; break;
22519                                           default: assert(0);
22520                                         } /* (MATCH_w_8_16 & 0x7) 
22521                                               -- r_m at 16 --*/ 
22522                                       break;
22523                                     case 1: 
22524                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
22525                                       if ((MATCH_w_8_16 & 0x7) 
22526                                               /* r_m at 16 */ == 4 && 
22527                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22528                                               /* index at 24 */ && 
22529                                         (MATCH_w_8_24 >> 3 & 0x7) 
22530                                               /* index at 24 */ < 8)) { 
22531                                         unsigned Eaddr = 
22532                                           2 + addressToPC(MATCH_p);
22533                                         unsigned reg = 
22534                                           (MATCH_w_8_16 >> 3 & 0x7) 
22535                                                 /* reg_opcode at 16 */;
22536                                         nextPC = 5 + MATCH_p; 
22537                                         
22538 #line 1025 "frontend/machine/pentium/decoder.m"
22539                                         
22540 
22541                                                 stmts = instantiate(pc,  "MOVrmow", DIS_REG16, DIS_EADDR16);
22542 
22543                                         
22544 
22545                                         
22546                                         
22547                                         
22548                                       } /*opt-block*//*opt-block+*/
22549                                       else 
22550                                         goto MATCH_label_c290;  /*opt-block+*/
22551                                       
22552                                       break;
22553                                     case 2: 
22554                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
22555                                       if ((MATCH_w_8_16 & 0x7) 
22556                                               /* r_m at 16 */ == 4 && 
22557                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22558                                               /* index at 24 */ && 
22559                                         (MATCH_w_8_24 >> 3 & 0x7) 
22560                                               /* index at 24 */ < 8)) 
22561                                         goto MATCH_label_c291;  /*opt-block+*/
22562                                       else 
22563                                         goto MATCH_label_c292;  /*opt-block+*/
22564                                       
22565                                       break;
22566                                     case 3: 
22567                                       goto MATCH_label_c289; break;
22568                                     default: assert(0);
22569                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
22570                                         -- mod at 16 --*/ 
22571                                 
22572                               } /*opt-block*/
22573                               else { 
22574                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
22575                                 
22576                                   switch((MATCH_w_8_16 >> 3 & 0x7) 
22577                                         /* reg_opcode at 16 */) {
22578                                     case 0: 
22579                                       
22580                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
22581                                               /* mod at 16 */) {
22582                                           case 0: 
22583                                             
22584                                               switch((MATCH_w_8_16 & 0x7) 
22585                                                     /* r_m at 16 */) {
22586                                                 case 0: case 1: case 2: 
22587                                                 case 3: case 6: case 7: 
22588                                                   MATCH_w_8_24 = 
22589                                                     getByte(3 + MATCH_p); 
22590                                                   goto MATCH_label_c257; 
22591                                                   
22592                                                   break;
22593                                                 case 4: 
22594                                                   MATCH_w_8_24 = 
22595                                                     getByte(3 + MATCH_p); 
22596                                                   if ((MATCH_w_8_24 & 0x7) 
22597                                                           /* base at 24 */ == 5 && 
22598                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22599                                                           /* index at 24 */ && 
22600                                                     (MATCH_w_8_24 >> 3 & 0x7) 
22601                                                           /* index at 24 */ < 8)) { 
22602                                                     MATCH_w_8_64 = 
22603                                                       getByte(8 + MATCH_p); 
22604                                                     goto MATCH_label_c259; 
22605                                                     
22606                                                   } /*opt-block*/
22607                                                   else { 
22608                                                     MATCH_w_8_32 = 
22609                                                       getByte(4 + MATCH_p); 
22610                                                     goto MATCH_label_c258; 
22611                                                     
22612                                                   } /*opt-block*/
22613                                                   
22614                                                   break;
22615                                                 case 5: 
22616                                                   MATCH_w_8_56 = 
22617                                                     getByte(7 + MATCH_p); 
22618                                                   goto MATCH_label_c260; 
22619                                                   
22620                                                   break;
22621                                                 default: assert(0);
22622                                               } /* (MATCH_w_8_16 & 0x7) 
22623                                                     -- r_m at 16 --*/ 
22624                                             break;
22625                                           case 1: 
22626                                             MATCH_w_8_24 = 
22627                                               getByte(3 + MATCH_p); 
22628                                             if ((MATCH_w_8_16 & 0x7) 
22629                                                     /* r_m at 16 */ == 4 && 
22630                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22631                                                     /* index at 24 */ && 
22632                                               (MATCH_w_8_24 >> 3 & 0x7) 
22633                                                     /* index at 24 */ < 8)) { 
22634                                               MATCH_w_8_40 = 
22635                                                 getByte(5 + MATCH_p); 
22636                                               { 
22637                                                 unsigned Eaddr = 
22638                                                   2 + addressToPC(MATCH_p);
22639                                                 int /* [~128..127] */ i8 = 
22640                                                   sign_extend((MATCH_w_8_40 & 0xff) 
22641                                                                     /* i8 at 40 */, 
22642                                                               8);
22643                                                 nextPC = 6 + MATCH_p; 
22644                                                 
22645 #line 1597 "frontend/machine/pentium/decoder.m"
22646                                                 
22647 
22648                                                         stmts = instantiate(pc,  "ADDiowb", DIS_EADDR16, DIS_I8);
22649 
22650                                                 
22651 
22652                                                 
22653                                                 
22654                                                 
22655                                               }
22656                                               
22657                                             } /*opt-block*/
22658                                             else { 
22659                                               MATCH_w_8_32 = 
22660                                                 getByte(4 + MATCH_p); 
22661                                               goto MATCH_label_c258; 
22662                                               
22663                                             } /*opt-block*/
22664                                             
22665                                             break;
22666                                           case 2: 
22667                                             MATCH_w_8_24 = 
22668                                               getByte(3 + MATCH_p); 
22669                                             if ((MATCH_w_8_16 & 0x7) 
22670                                                     /* r_m at 16 */ == 4 && 
22671                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22672                                                     /* index at 24 */ && 
22673                                               (MATCH_w_8_24 >> 3 & 0x7) 
22674                                                     /* index at 24 */ < 8)) { 
22675                                               MATCH_w_8_64 = 
22676                                                 getByte(8 + MATCH_p); 
22677                                               goto MATCH_label_c259; 
22678                                               
22679                                             } /*opt-block*/
22680                                             else { 
22681                                               MATCH_w_8_56 = 
22682                                                 getByte(7 + MATCH_p); 
22683                                               goto MATCH_label_c260; 
22684                                               
22685                                             } /*opt-block*/
22686                                             
22687                                             break;
22688                                           case 3: 
22689                                             MATCH_w_8_24 = 
22690                                               getByte(3 + MATCH_p); 
22691                                             goto MATCH_label_c257; 
22692                                             
22693                                             break;
22694                                           default: assert(0);
22695                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
22696                                               -- mod at 16 --*/ 
22697                                       break;
22698                                     case 1: 
22699                                       
22700                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
22701                                               /* mod at 16 */) {
22702                                           case 0: 
22703                                             
22704                                               switch((MATCH_w_8_16 & 0x7) 
22705                                                     /* r_m at 16 */) {
22706                                                 case 0: case 1: case 2: 
22707                                                 case 3: case 6: case 7: 
22708                                                   MATCH_w_8_24 = 
22709                                                     getByte(3 + MATCH_p); 
22710                                                   goto MATCH_label_c261; 
22711                                                   
22712                                                   break;
22713                                                 case 4: 
22714                                                   MATCH_w_8_24 = 
22715                                                     getByte(3 + MATCH_p); 
22716                                                   if ((MATCH_w_8_24 & 0x7) 
22717                                                           /* base at 24 */ == 5 && 
22718                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22719                                                           /* index at 24 */ && 
22720                                                     (MATCH_w_8_24 >> 3 & 0x7) 
22721                                                           /* index at 24 */ < 8)) { 
22722                                                     MATCH_w_8_64 = 
22723                                                       getByte(8 + MATCH_p); 
22724                                                     goto MATCH_label_c263; 
22725                                                     
22726                                                   } /*opt-block*/
22727                                                   else { 
22728                                                     MATCH_w_8_32 = 
22729                                                       getByte(4 + MATCH_p); 
22730                                                     goto MATCH_label_c262; 
22731                                                     
22732                                                   } /*opt-block*/
22733                                                   
22734                                                   break;
22735                                                 case 5: 
22736                                                   MATCH_w_8_56 = 
22737                                                     getByte(7 + MATCH_p); 
22738                                                   goto MATCH_label_c264; 
22739                                                   
22740                                                   break;
22741                                                 default: assert(0);
22742                                               } /* (MATCH_w_8_16 & 0x7) 
22743                                                     -- r_m at 16 --*/ 
22744                                             break;
22745                                           case 1: 
22746                                             MATCH_w_8_24 = 
22747                                               getByte(3 + MATCH_p); 
22748                                             if ((MATCH_w_8_16 & 0x7) 
22749                                                     /* r_m at 16 */ == 4 && 
22750                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22751                                                     /* index at 24 */ && 
22752                                               (MATCH_w_8_24 >> 3 & 0x7) 
22753                                                     /* index at 24 */ < 8)) { 
22754                                               MATCH_w_8_40 = 
22755                                                 getByte(5 + MATCH_p); 
22756                                               { 
22757                                                 unsigned Eaddr = 
22758                                                   2 + addressToPC(MATCH_p);
22759                                                 int /* [~128..127] */ i8 = 
22760                                                   sign_extend((MATCH_w_8_40 & 0xff) 
22761                                                                     /* i8 at 40 */, 
22762                                                               8);
22763                                                 nextPC = 6 + MATCH_p; 
22764                                                 
22765 #line 1591 "frontend/machine/pentium/decoder.m"
22766                                                 
22767 
22768                                                         stmts = instantiate(pc,  "ORiowb", DIS_EADDR16, DIS_I8);
22769 
22770                                                 
22771 
22772                                                 
22773                                                 
22774                                                 
22775                                               }
22776                                               
22777                                             } /*opt-block*/
22778                                             else { 
22779                                               MATCH_w_8_32 = 
22780                                                 getByte(4 + MATCH_p); 
22781                                               goto MATCH_label_c262; 
22782                                               
22783                                             } /*opt-block*/
22784                                             
22785                                             break;
22786                                           case 2: 
22787                                             MATCH_w_8_24 = 
22788                                               getByte(3 + MATCH_p); 
22789                                             if ((MATCH_w_8_16 & 0x7) 
22790                                                     /* r_m at 16 */ == 4 && 
22791                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22792                                                     /* index at 24 */ && 
22793                                               (MATCH_w_8_24 >> 3 & 0x7) 
22794                                                     /* index at 24 */ < 8)) { 
22795                                               MATCH_w_8_64 = 
22796                                                 getByte(8 + MATCH_p); 
22797                                               goto MATCH_label_c263; 
22798                                               
22799                                             } /*opt-block*/
22800                                             else { 
22801                                               MATCH_w_8_56 = 
22802                                                 getByte(7 + MATCH_p); 
22803                                               goto MATCH_label_c264; 
22804                                               
22805                                             } /*opt-block*/
22806                                             
22807                                             break;
22808                                           case 3: 
22809                                             MATCH_w_8_24 = 
22810                                               getByte(3 + MATCH_p); 
22811                                             goto MATCH_label_c261; 
22812                                             
22813                                             break;
22814                                           default: assert(0);
22815                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
22816                                               -- mod at 16 --*/ 
22817                                       break;
22818                                     case 2: 
22819                                       
22820                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
22821                                               /* mod at 16 */) {
22822                                           case 0: 
22823                                             
22824                                               switch((MATCH_w_8_16 & 0x7) 
22825                                                     /* r_m at 16 */) {
22826                                                 case 0: case 1: case 2: 
22827                                                 case 3: case 6: case 7: 
22828                                                   MATCH_w_8_24 = 
22829                                                     getByte(3 + MATCH_p); 
22830                                                   goto MATCH_label_c265; 
22831                                                   
22832                                                   break;
22833                                                 case 4: 
22834                                                   MATCH_w_8_24 = 
22835                                                     getByte(3 + MATCH_p); 
22836                                                   if ((MATCH_w_8_24 & 0x7) 
22837                                                           /* base at 24 */ == 5 && 
22838                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22839                                                           /* index at 24 */ && 
22840                                                     (MATCH_w_8_24 >> 3 & 0x7) 
22841                                                           /* index at 24 */ < 8)) { 
22842                                                     MATCH_w_8_64 = 
22843                                                       getByte(8 + MATCH_p); 
22844                                                     goto MATCH_label_c267; 
22845                                                     
22846                                                   } /*opt-block*/
22847                                                   else { 
22848                                                     MATCH_w_8_32 = 
22849                                                       getByte(4 + MATCH_p); 
22850                                                     goto MATCH_label_c266; 
22851                                                     
22852                                                   } /*opt-block*/
22853                                                   
22854                                                   break;
22855                                                 case 5: 
22856                                                   MATCH_w_8_56 = 
22857                                                     getByte(7 + MATCH_p); 
22858                                                   goto MATCH_label_c268; 
22859                                                   
22860                                                   break;
22861                                                 default: assert(0);
22862                                               } /* (MATCH_w_8_16 & 0x7) 
22863                                                     -- r_m at 16 --*/ 
22864                                             break;
22865                                           case 1: 
22866                                             MATCH_w_8_24 = 
22867                                               getByte(3 + MATCH_p); 
22868                                             if ((MATCH_w_8_16 & 0x7) 
22869                                                     /* r_m at 16 */ == 4 && 
22870                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22871                                                     /* index at 24 */ && 
22872                                               (MATCH_w_8_24 >> 3 & 0x7) 
22873                                                     /* index at 24 */ < 8)) { 
22874                                               MATCH_w_8_40 = 
22875                                                 getByte(5 + MATCH_p); 
22876                                               { 
22877                                                 unsigned Eaddr = 
22878                                                   2 + addressToPC(MATCH_p);
22879                                                 int /* [~128..127] */ i8 = 
22880                                                   sign_extend((MATCH_w_8_40 & 0xff) 
22881                                                                     /* i8 at 40 */, 
22882                                                               8);
22883                                                 nextPC = 6 + MATCH_p; 
22884                                                 
22885 #line 1585 "frontend/machine/pentium/decoder.m"
22886                                                 
22887 
22888                                                         stmts = instantiate(pc,  "ADCiowb", DIS_EADDR16, DIS_I8);
22889 
22890                                                 
22891 
22892                                                 
22893                                                 
22894                                                 
22895                                               }
22896                                               
22897                                             } /*opt-block*/
22898                                             else { 
22899                                               MATCH_w_8_32 = 
22900                                                 getByte(4 + MATCH_p); 
22901                                               goto MATCH_label_c266; 
22902                                               
22903                                             } /*opt-block*/
22904                                             
22905                                             break;
22906                                           case 2: 
22907                                             MATCH_w_8_24 = 
22908                                               getByte(3 + MATCH_p); 
22909                                             if ((MATCH_w_8_16 & 0x7) 
22910                                                     /* r_m at 16 */ == 4 && 
22911                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22912                                                     /* index at 24 */ && 
22913                                               (MATCH_w_8_24 >> 3 & 0x7) 
22914                                                     /* index at 24 */ < 8)) { 
22915                                               MATCH_w_8_64 = 
22916                                                 getByte(8 + MATCH_p); 
22917                                               goto MATCH_label_c267; 
22918                                               
22919                                             } /*opt-block*/
22920                                             else { 
22921                                               MATCH_w_8_56 = 
22922                                                 getByte(7 + MATCH_p); 
22923                                               goto MATCH_label_c268; 
22924                                               
22925                                             } /*opt-block*/
22926                                             
22927                                             break;
22928                                           case 3: 
22929                                             MATCH_w_8_24 = 
22930                                               getByte(3 + MATCH_p); 
22931                                             goto MATCH_label_c265; 
22932                                             
22933                                             break;
22934                                           default: assert(0);
22935                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
22936                                               -- mod at 16 --*/ 
22937                                       break;
22938                                     case 3: 
22939                                       
22940                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
22941                                               /* mod at 16 */) {
22942                                           case 0: 
22943                                             
22944                                               switch((MATCH_w_8_16 & 0x7) 
22945                                                     /* r_m at 16 */) {
22946                                                 case 0: case 1: case 2: 
22947                                                 case 3: case 6: case 7: 
22948                                                   MATCH_w_8_24 = 
22949                                                     getByte(3 + MATCH_p); 
22950                                                   goto MATCH_label_c269; 
22951                                                   
22952                                                   break;
22953                                                 case 4: 
22954                                                   MATCH_w_8_24 = 
22955                                                     getByte(3 + MATCH_p); 
22956                                                   if ((MATCH_w_8_24 & 0x7) 
22957                                                           /* base at 24 */ == 5 && 
22958                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22959                                                           /* index at 24 */ && 
22960                                                     (MATCH_w_8_24 >> 3 & 0x7) 
22961                                                           /* index at 24 */ < 8)) { 
22962                                                     MATCH_w_8_64 = 
22963                                                       getByte(8 + MATCH_p); 
22964                                                     goto MATCH_label_c271; 
22965                                                     
22966                                                   } /*opt-block*/
22967                                                   else { 
22968                                                     MATCH_w_8_32 = 
22969                                                       getByte(4 + MATCH_p); 
22970                                                     goto MATCH_label_c270; 
22971                                                     
22972                                                   } /*opt-block*/
22973                                                   
22974                                                   break;
22975                                                 case 5: 
22976                                                   MATCH_w_8_56 = 
22977                                                     getByte(7 + MATCH_p); 
22978                                                   goto MATCH_label_c272; 
22979                                                   
22980                                                   break;
22981                                                 default: assert(0);
22982                                               } /* (MATCH_w_8_16 & 0x7) 
22983                                                     -- r_m at 16 --*/ 
22984                                             break;
22985                                           case 1: 
22986                                             MATCH_w_8_24 = 
22987                                               getByte(3 + MATCH_p); 
22988                                             if ((MATCH_w_8_16 & 0x7) 
22989                                                     /* r_m at 16 */ == 4 && 
22990                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
22991                                                     /* index at 24 */ && 
22992                                               (MATCH_w_8_24 >> 3 & 0x7) 
22993                                                     /* index at 24 */ < 8)) { 
22994                                               MATCH_w_8_40 = 
22995                                                 getByte(5 + MATCH_p); 
22996                                               { 
22997                                                 unsigned Eaddr = 
22998                                                   2 + addressToPC(MATCH_p);
22999                                                 int /* [~128..127] */ i8 = 
23000                                                   sign_extend((MATCH_w_8_40 & 0xff) 
23001                                                                     /* i8 at 40 */, 
23002                                                               8);
23003                                                 nextPC = 6 + MATCH_p; 
23004                                                 
23005 #line 1579 "frontend/machine/pentium/decoder.m"
23006                                                 
23007 
23008                                                         stmts = instantiate(pc,  "SBBiowb", DIS_EADDR16, DIS_I8);
23009 
23010                                                 
23011 
23012                                                 
23013                                                 
23014                                                 
23015                                               }
23016                                               
23017                                             } /*opt-block*/
23018                                             else { 
23019                                               MATCH_w_8_32 = 
23020                                                 getByte(4 + MATCH_p); 
23021                                               goto MATCH_label_c270; 
23022                                               
23023                                             } /*opt-block*/
23024                                             
23025                                             break;
23026                                           case 2: 
23027                                             MATCH_w_8_24 = 
23028                                               getByte(3 + MATCH_p); 
23029                                             if ((MATCH_w_8_16 & 0x7) 
23030                                                     /* r_m at 16 */ == 4 && 
23031                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23032                                                     /* index at 24 */ && 
23033                                               (MATCH_w_8_24 >> 3 & 0x7) 
23034                                                     /* index at 24 */ < 8)) { 
23035                                               MATCH_w_8_64 = 
23036                                                 getByte(8 + MATCH_p); 
23037                                               goto MATCH_label_c271; 
23038                                               
23039                                             } /*opt-block*/
23040                                             else { 
23041                                               MATCH_w_8_56 = 
23042                                                 getByte(7 + MATCH_p); 
23043                                               goto MATCH_label_c272; 
23044                                               
23045                                             } /*opt-block*/
23046                                             
23047                                             break;
23048                                           case 3: 
23049                                             MATCH_w_8_24 = 
23050                                               getByte(3 + MATCH_p); 
23051                                             goto MATCH_label_c269; 
23052                                             
23053                                             break;
23054                                           default: assert(0);
23055                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
23056                                               -- mod at 16 --*/ 
23057                                       break;
23058                                     case 4: 
23059                                       
23060                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
23061                                               /* mod at 16 */) {
23062                                           case 0: 
23063                                             
23064                                               switch((MATCH_w_8_16 & 0x7) 
23065                                                     /* r_m at 16 */) {
23066                                                 case 0: case 1: case 2: 
23067                                                 case 3: case 6: case 7: 
23068                                                   MATCH_w_8_24 = 
23069                                                     getByte(3 + MATCH_p); 
23070                                                   goto MATCH_label_c273; 
23071                                                   
23072                                                   break;
23073                                                 case 4: 
23074                                                   MATCH_w_8_24 = 
23075                                                     getByte(3 + MATCH_p); 
23076                                                   if ((MATCH_w_8_24 & 0x7) 
23077                                                           /* base at 24 */ == 5 && 
23078                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23079                                                           /* index at 24 */ && 
23080                                                     (MATCH_w_8_24 >> 3 & 0x7) 
23081                                                           /* index at 24 */ < 8)) { 
23082                                                     MATCH_w_8_64 = 
23083                                                       getByte(8 + MATCH_p); 
23084                                                     goto MATCH_label_c275; 
23085                                                     
23086                                                   } /*opt-block*/
23087                                                   else { 
23088                                                     MATCH_w_8_32 = 
23089                                                       getByte(4 + MATCH_p); 
23090                                                     goto MATCH_label_c274; 
23091                                                     
23092                                                   } /*opt-block*/
23093                                                   
23094                                                   break;
23095                                                 case 5: 
23096                                                   MATCH_w_8_56 = 
23097                                                     getByte(7 + MATCH_p); 
23098                                                   goto MATCH_label_c276; 
23099                                                   
23100                                                   break;
23101                                                 default: assert(0);
23102                                               } /* (MATCH_w_8_16 & 0x7) 
23103                                                     -- r_m at 16 --*/ 
23104                                             break;
23105                                           case 1: 
23106                                             MATCH_w_8_24 = 
23107                                               getByte(3 + MATCH_p); 
23108                                             if ((MATCH_w_8_16 & 0x7) 
23109                                                     /* r_m at 16 */ == 4 && 
23110                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23111                                                     /* index at 24 */ && 
23112                                               (MATCH_w_8_24 >> 3 & 0x7) 
23113                                                     /* index at 24 */ < 8)) { 
23114                                               MATCH_w_8_40 = 
23115                                                 getByte(5 + MATCH_p); 
23116                                               { 
23117                                                 unsigned Eaddr = 
23118                                                   2 + addressToPC(MATCH_p);
23119                                                 int /* [~128..127] */ i8 = 
23120                                                   sign_extend((MATCH_w_8_40 & 0xff) 
23121                                                                     /* i8 at 40 */, 
23122                                                               8);
23123                                                 nextPC = 6 + MATCH_p; 
23124                                                 
23125 #line 1573 "frontend/machine/pentium/decoder.m"
23126                                                 
23127 
23128                                                         stmts = instantiate(pc,  "ANDiowb", DIS_EADDR16, DIS_I8);
23129 
23130                                                 
23131 
23132                                                 
23133                                                 
23134                                                 
23135                                               }
23136                                               
23137                                             } /*opt-block*/
23138                                             else { 
23139                                               MATCH_w_8_32 = 
23140                                                 getByte(4 + MATCH_p); 
23141                                               goto MATCH_label_c274; 
23142                                               
23143                                             } /*opt-block*/
23144                                             
23145                                             break;
23146                                           case 2: 
23147                                             MATCH_w_8_24 = 
23148                                               getByte(3 + MATCH_p); 
23149                                             if ((MATCH_w_8_16 & 0x7) 
23150                                                     /* r_m at 16 */ == 4 && 
23151                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23152                                                     /* index at 24 */ && 
23153                                               (MATCH_w_8_24 >> 3 & 0x7) 
23154                                                     /* index at 24 */ < 8)) { 
23155                                               MATCH_w_8_64 = 
23156                                                 getByte(8 + MATCH_p); 
23157                                               goto MATCH_label_c275; 
23158                                               
23159                                             } /*opt-block*/
23160                                             else { 
23161                                               MATCH_w_8_56 = 
23162                                                 getByte(7 + MATCH_p); 
23163                                               goto MATCH_label_c276; 
23164                                               
23165                                             } /*opt-block*/
23166                                             
23167                                             break;
23168                                           case 3: 
23169                                             MATCH_w_8_24 = 
23170                                               getByte(3 + MATCH_p); 
23171                                             goto MATCH_label_c273; 
23172                                             
23173                                             break;
23174                                           default: assert(0);
23175                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
23176                                               -- mod at 16 --*/ 
23177                                       break;
23178                                     case 5: 
23179                                       
23180                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
23181                                               /* mod at 16 */) {
23182                                           case 0: 
23183                                             
23184                                               switch((MATCH_w_8_16 & 0x7) 
23185                                                     /* r_m at 16 */) {
23186                                                 case 0: case 1: case 2: 
23187                                                 case 3: case 6: case 7: 
23188                                                   MATCH_w_8_24 = 
23189                                                     getByte(3 + MATCH_p); 
23190                                                   goto MATCH_label_c277; 
23191                                                   
23192                                                   break;
23193                                                 case 4: 
23194                                                   MATCH_w_8_24 = 
23195                                                     getByte(3 + MATCH_p); 
23196                                                   if ((MATCH_w_8_24 & 0x7) 
23197                                                           /* base at 24 */ == 5 && 
23198                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23199                                                           /* index at 24 */ && 
23200                                                     (MATCH_w_8_24 >> 3 & 0x7) 
23201                                                           /* index at 24 */ < 8)) { 
23202                                                     MATCH_w_8_64 = 
23203                                                       getByte(8 + MATCH_p); 
23204                                                     goto MATCH_label_c279; 
23205                                                     
23206                                                   } /*opt-block*/
23207                                                   else { 
23208                                                     MATCH_w_8_32 = 
23209                                                       getByte(4 + MATCH_p); 
23210                                                     goto MATCH_label_c278; 
23211                                                     
23212                                                   } /*opt-block*/
23213                                                   
23214                                                   break;
23215                                                 case 5: 
23216                                                   MATCH_w_8_56 = 
23217                                                     getByte(7 + MATCH_p); 
23218                                                   goto MATCH_label_c280; 
23219                                                   
23220                                                   break;
23221                                                 default: assert(0);
23222                                               } /* (MATCH_w_8_16 & 0x7) 
23223                                                     -- r_m at 16 --*/ 
23224                                             break;
23225                                           case 1: 
23226                                             MATCH_w_8_24 = 
23227                                               getByte(3 + MATCH_p); 
23228                                             if ((MATCH_w_8_16 & 0x7) 
23229                                                     /* r_m at 16 */ == 4 && 
23230                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23231                                                     /* index at 24 */ && 
23232                                               (MATCH_w_8_24 >> 3 & 0x7) 
23233                                                     /* index at 24 */ < 8)) { 
23234                                               MATCH_w_8_40 = 
23235                                                 getByte(5 + MATCH_p); 
23236                                               { 
23237                                                 unsigned Eaddr = 
23238                                                   2 + addressToPC(MATCH_p);
23239                                                 int /* [~128..127] */ i8 = 
23240                                                   sign_extend((MATCH_w_8_40 & 0xff) 
23241                                                                     /* i8 at 40 */, 
23242                                                               8);
23243                                                 nextPC = 6 + MATCH_p; 
23244                                                 
23245 #line 1564 "frontend/machine/pentium/decoder.m"
23246                                                 
23247 
23248                                                         stmts = instantiate(pc,  "SUBiowb", DIS_EADDR16, DIS_I8);
23249 
23250                                                 
23251 
23252                                                 
23253                                                 
23254                                                 
23255                                               }
23256                                               
23257                                             } /*opt-block*/
23258                                             else { 
23259                                               MATCH_w_8_32 = 
23260                                                 getByte(4 + MATCH_p); 
23261                                               goto MATCH_label_c278; 
23262                                               
23263                                             } /*opt-block*/
23264                                             
23265                                             break;
23266                                           case 2: 
23267                                             MATCH_w_8_24 = 
23268                                               getByte(3 + MATCH_p); 
23269                                             if ((MATCH_w_8_16 & 0x7) 
23270                                                     /* r_m at 16 */ == 4 && 
23271                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23272                                                     /* index at 24 */ && 
23273                                               (MATCH_w_8_24 >> 3 & 0x7) 
23274                                                     /* index at 24 */ < 8)) { 
23275                                               MATCH_w_8_64 = 
23276                                                 getByte(8 + MATCH_p); 
23277                                               goto MATCH_label_c279; 
23278                                               
23279                                             } /*opt-block*/
23280                                             else { 
23281                                               MATCH_w_8_56 = 
23282                                                 getByte(7 + MATCH_p); 
23283                                               goto MATCH_label_c280; 
23284                                               
23285                                             } /*opt-block*/
23286                                             
23287                                             break;
23288                                           case 3: 
23289                                             MATCH_w_8_24 = 
23290                                               getByte(3 + MATCH_p); 
23291                                             goto MATCH_label_c277; 
23292                                             
23293                                             break;
23294                                           default: assert(0);
23295                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
23296                                               -- mod at 16 --*/ 
23297                                       break;
23298                                     case 6: 
23299                                       
23300                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
23301                                               /* mod at 16 */) {
23302                                           case 0: 
23303                                             
23304                                               switch((MATCH_w_8_16 & 0x7) 
23305                                                     /* r_m at 16 */) {
23306                                                 case 0: case 1: case 2: 
23307                                                 case 3: case 6: case 7: 
23308                                                   MATCH_w_8_24 = 
23309                                                     getByte(3 + MATCH_p); 
23310                                                   goto MATCH_label_c281; 
23311                                                   
23312                                                   break;
23313                                                 case 4: 
23314                                                   MATCH_w_8_24 = 
23315                                                     getByte(3 + MATCH_p); 
23316                                                   if ((MATCH_w_8_24 & 0x7) 
23317                                                           /* base at 24 */ == 5 && 
23318                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23319                                                           /* index at 24 */ && 
23320                                                     (MATCH_w_8_24 >> 3 & 0x7) 
23321                                                           /* index at 24 */ < 8)) { 
23322                                                     MATCH_w_8_64 = 
23323                                                       getByte(8 + MATCH_p); 
23324                                                     goto MATCH_label_c283; 
23325                                                     
23326                                                   } /*opt-block*/
23327                                                   else { 
23328                                                     MATCH_w_8_32 = 
23329                                                       getByte(4 + MATCH_p); 
23330                                                     goto MATCH_label_c282; 
23331                                                     
23332                                                   } /*opt-block*/
23333                                                   
23334                                                   break;
23335                                                 case 5: 
23336                                                   MATCH_w_8_56 = 
23337                                                     getByte(7 + MATCH_p); 
23338                                                   goto MATCH_label_c284; 
23339                                                   
23340                                                   break;
23341                                                 default: assert(0);
23342                                               } /* (MATCH_w_8_16 & 0x7) 
23343                                                     -- r_m at 16 --*/ 
23344                                             break;
23345                                           case 1: 
23346                                             MATCH_w_8_24 = 
23347                                               getByte(3 + MATCH_p); 
23348                                             if ((MATCH_w_8_16 & 0x7) 
23349                                                     /* r_m at 16 */ == 4 && 
23350                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23351                                                     /* index at 24 */ && 
23352                                               (MATCH_w_8_24 >> 3 & 0x7) 
23353                                                     /* index at 24 */ < 8)) { 
23354                                               MATCH_w_8_40 = 
23355                                                 getByte(5 + MATCH_p); 
23356                                               { 
23357                                                 unsigned Eaddr = 
23358                                                   2 + addressToPC(MATCH_p);
23359                                                 int /* [~128..127] */ i8 = 
23360                                                   sign_extend((MATCH_w_8_40 & 0xff) 
23361                                                                     /* i8 at 40 */, 
23362                                                               8);
23363                                                 nextPC = 6 + MATCH_p; 
23364                                                 
23365 #line 1558 "frontend/machine/pentium/decoder.m"
23366                                                 
23367 
23368                                                         stmts = instantiate(pc,  "XORiowb", DIS_EADDR16, DIS_I8);
23369 
23370                                                 
23371 
23372                                                 
23373                                                 
23374                                                 
23375                                               }
23376                                               
23377                                             } /*opt-block*/
23378                                             else { 
23379                                               MATCH_w_8_32 = 
23380                                                 getByte(4 + MATCH_p); 
23381                                               goto MATCH_label_c282; 
23382                                               
23383                                             } /*opt-block*/
23384                                             
23385                                             break;
23386                                           case 2: 
23387                                             MATCH_w_8_24 = 
23388                                               getByte(3 + MATCH_p); 
23389                                             if ((MATCH_w_8_16 & 0x7) 
23390                                                     /* r_m at 16 */ == 4 && 
23391                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23392                                                     /* index at 24 */ && 
23393                                               (MATCH_w_8_24 >> 3 & 0x7) 
23394                                                     /* index at 24 */ < 8)) { 
23395                                               MATCH_w_8_64 = 
23396                                                 getByte(8 + MATCH_p); 
23397                                               goto MATCH_label_c283; 
23398                                               
23399                                             } /*opt-block*/
23400                                             else { 
23401                                               MATCH_w_8_56 = 
23402                                                 getByte(7 + MATCH_p); 
23403                                               goto MATCH_label_c284; 
23404                                               
23405                                             } /*opt-block*/
23406                                             
23407                                             break;
23408                                           case 3: 
23409                                             MATCH_w_8_24 = 
23410                                               getByte(3 + MATCH_p); 
23411                                             goto MATCH_label_c281; 
23412                                             
23413                                             break;
23414                                           default: assert(0);
23415                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
23416                                               -- mod at 16 --*/ 
23417                                       break;
23418                                     case 7: 
23419                                       
23420                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
23421                                               /* mod at 16 */) {
23422                                           case 0: 
23423                                             
23424                                               switch((MATCH_w_8_16 & 0x7) 
23425                                                     /* r_m at 16 */) {
23426                                                 case 0: case 1: case 2: 
23427                                                 case 3: case 6: case 7: 
23428                                                   MATCH_w_8_24 = 
23429                                                     getByte(3 + MATCH_p); 
23430                                                   goto MATCH_label_c285; 
23431                                                   
23432                                                   break;
23433                                                 case 4: 
23434                                                   MATCH_w_8_24 = 
23435                                                     getByte(3 + MATCH_p); 
23436                                                   if ((MATCH_w_8_24 & 0x7) 
23437                                                           /* base at 24 */ == 5 && 
23438                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23439                                                           /* index at 24 */ && 
23440                                                     (MATCH_w_8_24 >> 3 & 0x7) 
23441                                                           /* index at 24 */ < 8)) { 
23442                                                     MATCH_w_8_64 = 
23443                                                       getByte(8 + MATCH_p); 
23444                                                     goto MATCH_label_c287; 
23445                                                     
23446                                                   } /*opt-block*/
23447                                                   else { 
23448                                                     MATCH_w_8_32 = 
23449                                                       getByte(4 + MATCH_p); 
23450                                                     goto MATCH_label_c286; 
23451                                                     
23452                                                   } /*opt-block*/
23453                                                   
23454                                                   break;
23455                                                 case 5: 
23456                                                   MATCH_w_8_56 = 
23457                                                     getByte(7 + MATCH_p); 
23458                                                   goto MATCH_label_c288; 
23459                                                   
23460                                                   break;
23461                                                 default: assert(0);
23462                                               } /* (MATCH_w_8_16 & 0x7) 
23463                                                     -- r_m at 16 --*/ 
23464                                             break;
23465                                           case 1: 
23466                                             MATCH_w_8_24 = 
23467                                               getByte(3 + MATCH_p); 
23468                                             if ((MATCH_w_8_16 & 0x7) 
23469                                                     /* r_m at 16 */ == 4 && 
23470                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23471                                                     /* index at 24 */ && 
23472                                               (MATCH_w_8_24 >> 3 & 0x7) 
23473                                                     /* index at 24 */ < 8)) { 
23474                                               MATCH_w_8_40 = 
23475                                                 getByte(5 + MATCH_p); 
23476                                               { 
23477                                                 unsigned Eaddr = 
23478                                                   2 + addressToPC(MATCH_p);
23479                                                 int /* [~128..127] */ i8 = 
23480                                                   sign_extend((MATCH_w_8_40 & 0xff) 
23481                                                                     /* i8 at 40 */, 
23482                                                               8);
23483                                                 nextPC = 6 + MATCH_p; 
23484                                                 
23485 #line 1552 "frontend/machine/pentium/decoder.m"
23486                                                 
23487 
23488                                                         stmts = instantiate(pc,  "CMPiowb", DIS_EADDR16, DIS_I8);
23489 
23490                                                 
23491 
23492                                                 
23493                                                 
23494                                                 
23495                                               }
23496                                               
23497                                             } /*opt-block*/
23498                                             else { 
23499                                               MATCH_w_8_32 = 
23500                                                 getByte(4 + MATCH_p); 
23501                                               goto MATCH_label_c286; 
23502                                               
23503                                             } /*opt-block*/
23504                                             
23505                                             break;
23506                                           case 2: 
23507                                             MATCH_w_8_24 = 
23508                                               getByte(3 + MATCH_p); 
23509                                             if ((MATCH_w_8_16 & 0x7) 
23510                                                     /* r_m at 16 */ == 4 && 
23511                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23512                                                     /* index at 24 */ && 
23513                                               (MATCH_w_8_24 >> 3 & 0x7) 
23514                                                     /* index at 24 */ < 8)) { 
23515                                               MATCH_w_8_64 = 
23516                                                 getByte(8 + MATCH_p); 
23517                                               goto MATCH_label_c287; 
23518                                               
23519                                             } /*opt-block*/
23520                                             else { 
23521                                               MATCH_w_8_56 = 
23522                                                 getByte(7 + MATCH_p); 
23523                                               goto MATCH_label_c288; 
23524                                               
23525                                             } /*opt-block*/
23526                                             
23527                                             break;
23528                                           case 3: 
23529                                             MATCH_w_8_24 = 
23530                                               getByte(3 + MATCH_p); 
23531                                             goto MATCH_label_c285; 
23532                                             
23533                                             break;
23534                                           default: assert(0);
23535                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
23536                                               -- mod at 16 --*/ 
23537                                       break;
23538                                     default: assert(0);
23539                                   } /* (MATCH_w_8_16 >> 3 & 0x7) 
23540                                         -- reg_opcode at 16 --*/ 
23541                                 
23542                               } /*opt-block*/
23543                               break;
23544                             case 5: 
23545                               if ((MATCH_w_8_8 >> 3 & 0x1) 
23546                                       /* page at 8 */ == 1) { 
23547                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
23548                                 
23549                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
23550                                         /* mod at 16 */) {
23551                                     case 0: 
23552                                       
23553                                         switch((MATCH_w_8_16 & 0x7) 
23554                                               /* r_m at 16 */) {
23555                                           case 0: case 1: case 2: case 3: 
23556                                           case 6: case 7: 
23557                                             { 
23558                                               unsigned Mem = 
23559                                                 2 + addressToPC(MATCH_p);
23560                                               unsigned reg = 
23561                                                 (MATCH_w_8_16 >> 3 & 0x7) 
23562                                                       /* reg_opcode at 16 */;
23563                                               nextPC = 3 + MATCH_p; 
23564                                               
23565 #line 1076 "frontend/machine/pentium/decoder.m"
23566                                               
23567 
23568                                                     stmts = instantiate(pc,  "LEA.ow", DIS_REG16, DIS_MEM);
23569 
23570                                               
23571 
23572                                               
23573                                               
23574                                               
23575                                             }
23576                                             
23577                                             break;
23578                                           case 4: 
23579                                             MATCH_w_8_24 = 
23580                                               getByte(3 + MATCH_p); 
23581                                             if ((MATCH_w_8_24 & 0x7) 
23582                                                     /* base at 24 */ == 5 && 
23583                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23584                                                     /* index at 24 */ && 
23585                                               (MATCH_w_8_24 >> 3 & 0x7) 
23586                                                     /* index at 24 */ < 8)) 
23587                                               goto MATCH_label_c298;  /*opt-block+*/
23588                                             else 
23589                                               goto MATCH_label_c297;  /*opt-block+*/
23590                                             
23591                                             break;
23592                                           case 5: 
23593                                             goto MATCH_label_c299; break;
23594                                           default: assert(0);
23595                                         } /* (MATCH_w_8_16 & 0x7) 
23596                                               -- r_m at 16 --*/ 
23597                                       break;
23598                                     case 1: 
23599                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
23600                                       if ((MATCH_w_8_16 & 0x7) 
23601                                               /* r_m at 16 */ == 4 && 
23602                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23603                                               /* index at 24 */ && 
23604                                         (MATCH_w_8_24 >> 3 & 0x7) 
23605                                               /* index at 24 */ < 8)) { 
23606                                         unsigned Mem = 
23607                                           2 + addressToPC(MATCH_p);
23608                                         unsigned reg = 
23609                                           (MATCH_w_8_16 >> 3 & 0x7) 
23610                                                 /* reg_opcode at 16 */;
23611                                         nextPC = 5 + MATCH_p; 
23612                                         
23613 #line 1076 "frontend/machine/pentium/decoder.m"
23614                                         
23615 
23616                                                 stmts = instantiate(pc,  "LEA.ow", DIS_REG16, DIS_MEM);
23617 
23618                                         
23619 
23620                                         
23621                                         
23622                                         
23623                                       } /*opt-block*//*opt-block+*/
23624                                       else 
23625                                         goto MATCH_label_c297;  /*opt-block+*/
23626                                       
23627                                       break;
23628                                     case 2: 
23629                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
23630                                       if ((MATCH_w_8_16 & 0x7) 
23631                                               /* r_m at 16 */ == 4 && 
23632                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23633                                               /* index at 24 */ && 
23634                                         (MATCH_w_8_24 >> 3 & 0x7) 
23635                                               /* index at 24 */ < 8)) 
23636                                         goto MATCH_label_c298;  /*opt-block+*/
23637                                       else 
23638                                         goto MATCH_label_c299;  /*opt-block+*/
23639                                       
23640                                       break;
23641                                     case 3: 
23642                                       goto MATCH_label_c64; break;
23643                                     default: assert(0);
23644                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
23645                                         -- mod at 16 --*/ 
23646                                 
23647                               } /*opt-block*/
23648                               else { 
23649                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
23650                                 
23651                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
23652                                         /* mod at 16 */) {
23653                                     case 0: 
23654                                       
23655                                         switch((MATCH_w_8_16 & 0x7) 
23656                                               /* r_m at 16 */) {
23657                                           case 0: case 1: case 2: case 3: 
23658                                           case 6: case 7: 
23659                                             goto MATCH_label_c293; break;
23660                                           case 4: 
23661                                             MATCH_w_8_24 = 
23662                                               getByte(3 + MATCH_p); 
23663                                             if ((MATCH_w_8_24 & 0x7) 
23664                                                     /* base at 24 */ == 5 && 
23665                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23666                                                     /* index at 24 */ && 
23667                                               (MATCH_w_8_24 >> 3 & 0x7) 
23668                                                     /* index at 24 */ < 8)) 
23669                                               goto MATCH_label_c295;  /*opt-block+*/
23670                                             else 
23671                                               goto MATCH_label_c294;  /*opt-block+*/
23672                                             
23673                                             break;
23674                                           case 5: 
23675                                             goto MATCH_label_c296; break;
23676                                           default: assert(0);
23677                                         } /* (MATCH_w_8_16 & 0x7) 
23678                                               -- r_m at 16 --*/ 
23679                                       break;
23680                                     case 1: 
23681                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
23682                                       if ((MATCH_w_8_16 & 0x7) 
23683                                               /* r_m at 16 */ == 4 && 
23684                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23685                                               /* index at 24 */ && 
23686                                         (MATCH_w_8_24 >> 3 & 0x7) 
23687                                               /* index at 24 */ < 8)) { 
23688                                         unsigned Eaddr = 
23689                                           2 + addressToPC(MATCH_p);
23690                                         unsigned reg = 
23691                                           (MATCH_w_8_16 >> 3 & 0x7) 
23692                                                 /* reg_opcode at 16 */;
23693                                         nextPC = 5 + MATCH_p; 
23694                                         
23695 #line 381 "frontend/machine/pentium/decoder.m"
23696                                         
23697 
23698                                                 stmts = instantiate(pc,  "TEST.Ev.Gvow", DIS_EADDR16, DIS_REG16);
23699 
23700                                         
23701 
23702                                         
23703                                         
23704                                         
23705                                       } /*opt-block*//*opt-block+*/
23706                                       else 
23707                                         goto MATCH_label_c294;  /*opt-block+*/
23708                                       
23709                                       break;
23710                                     case 2: 
23711                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
23712                                       if ((MATCH_w_8_16 & 0x7) 
23713                                               /* r_m at 16 */ == 4 && 
23714                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23715                                               /* index at 24 */ && 
23716                                         (MATCH_w_8_24 >> 3 & 0x7) 
23717                                               /* index at 24 */ < 8)) 
23718                                         goto MATCH_label_c295;  /*opt-block+*/
23719                                       else 
23720                                         goto MATCH_label_c296;  /*opt-block+*/
23721                                       
23722                                       break;
23723                                     case 3: 
23724                                       goto MATCH_label_c293; break;
23725                                     default: assert(0);
23726                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
23727                                         -- mod at 16 --*/ 
23728                                 
23729                               } /*opt-block*/
23730                               break;
23731                             case 7: 
23732                               if ((MATCH_w_8_8 >> 3 & 0x1) 
23733                                       /* page at 8 */ == 1) { 
23734                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
23735                                 if ((MATCH_w_8_16 >> 3 & 0x7) 
23736                                         /* reg_opcode at 16 */ == 0) 
23737                                   
23738                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
23739                                           /* mod at 16 */) {
23740                                       case 0: 
23741                                         
23742                                           switch((MATCH_w_8_16 & 0x7) 
23743                                                 /* r_m at 16 */) {
23744                                             case 0: case 1: case 2: case 3: 
23745                                             case 6: case 7: 
23746                                               goto MATCH_label_c304; break;
23747                                             case 4: 
23748                                               MATCH_w_8_24 = 
23749                                                 getByte(3 + MATCH_p); 
23750                                               if ((MATCH_w_8_24 & 0x7) 
23751                                                       /* base at 24 */ == 5 && 
23752                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23753                                                       /* index at 24 */ && 
23754                                                 (MATCH_w_8_24 >> 3 & 0x7) 
23755                                                       /* index at 24 */ < 8)) 
23756                                                 goto MATCH_label_c306;  /*opt-block+*/
23757                                               else 
23758                                                 goto MATCH_label_c305;  /*opt-block+*/
23759                                               
23760                                               break;
23761                                             case 5: 
23762                                               goto MATCH_label_c307; break;
23763                                             default: assert(0);
23764                                           } /* (MATCH_w_8_16 & 0x7) 
23765                                                 -- r_m at 16 --*/ 
23766                                         break;
23767                                       case 1: 
23768                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
23769                                         if ((MATCH_w_8_16 & 0x7) 
23770                                                 /* r_m at 16 */ == 4 && 
23771                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23772                                                 /* index at 24 */ && 
23773                                           (MATCH_w_8_24 >> 3 & 0x7) 
23774                                                 /* index at 24 */ < 8)) { 
23775                                           unsigned Eaddr = 
23776                                             2 + addressToPC(MATCH_p);
23777                                           nextPC = 5 + MATCH_p; 
23778                                           
23779 #line 880 "frontend/machine/pentium/decoder.m"
23780                                           
23781 
23782                                                 stmts = instantiate(pc,  "POP.Evow", DIS_EADDR16);
23783 
23784                                           
23785 
23786                                           //      | OUTSvod() =>
23787 
23788                                           //          stmts = instantiate(pc,  "OUTSvod");
23789 
23790                                           
23791 
23792                                           //      | OUTSvow() =>
23793 
23794                                           //          stmts = instantiate(pc,  "OUTSvow");
23795 
23796                                           
23797 
23798                                           //      | OUTSB() =>
23799 
23800                                           //          stmts = instantiate(pc,  "OUTSB");
23801 
23802                                           
23803 
23804                                           //      | OUT.DX.eAXod() =>
23805 
23806                                           //          stmts = instantiate(pc,  "OUT.DX.eAXod");
23807 
23808                                           
23809 
23810                                           //      | OUT.DX.eAXow() =>
23811 
23812                                           //          stmts = instantiate(pc,  "OUT.DX.eAXow");
23813 
23814                                           
23815 
23816                                           //      | OUT.DX.AL() =>
23817 
23818                                           //          stmts = instantiate(pc,  "OUT.DX.AL");
23819 
23820                                           
23821 
23822                                           //      | OUT.Ib.eAXod(i8) =>
23823 
23824                                           //          stmts = instantiate(pc,  "OUT.Ib.eAXod", DIS_I8);
23825 
23826                                           
23827 
23828                                           //      | OUT.Ib.eAXow(i8) =>
23829 
23830                                           //          stmts = instantiate(pc,  "OUT.Ib.eAXow", DIS_I8);
23831 
23832                                           
23833 
23834                                           //      | OUT.Ib.AL(i8) =>
23835 
23836                                           //          stmts = instantiate(pc,  "OUT.Ib.AL", DIS_I8);
23837 
23838                                           
23839 
23840                                           
23841                                           
23842                                           
23843                                         } /*opt-block*//*opt-block+*/
23844                                         else 
23845                                           goto MATCH_label_c305;  /*opt-block+*/
23846                                         
23847                                         break;
23848                                       case 2: 
23849                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
23850                                         if ((MATCH_w_8_16 & 0x7) 
23851                                                 /* r_m at 16 */ == 4 && 
23852                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23853                                                 /* index at 24 */ && 
23854                                           (MATCH_w_8_24 >> 3 & 0x7) 
23855                                                 /* index at 24 */ < 8)) 
23856                                           goto MATCH_label_c306;  /*opt-block+*/
23857                                         else 
23858                                           goto MATCH_label_c307;  /*opt-block+*/
23859                                         
23860                                         break;
23861                                       case 3: 
23862                                         goto MATCH_label_c304; break;
23863                                       default: assert(0);
23864                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
23865                                           -- mod at 16 --*/  
23866                                 else 
23867                                   goto MATCH_label_c64;  /*opt-block+*/
23868                                 
23869                               } /*opt-block*/
23870                               else { 
23871                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
23872                                 
23873                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
23874                                         /* mod at 16 */) {
23875                                     case 0: 
23876                                       
23877                                         switch((MATCH_w_8_16 & 0x7) 
23878                                               /* r_m at 16 */) {
23879                                           case 0: case 1: case 2: case 3: 
23880                                           case 6: case 7: 
23881                                             goto MATCH_label_c300; break;
23882                                           case 4: 
23883                                             MATCH_w_8_24 = 
23884                                               getByte(3 + MATCH_p); 
23885                                             if ((MATCH_w_8_24 & 0x7) 
23886                                                     /* base at 24 */ == 5 && 
23887                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23888                                                     /* index at 24 */ && 
23889                                               (MATCH_w_8_24 >> 3 & 0x7) 
23890                                                     /* index at 24 */ < 8)) 
23891                                               goto MATCH_label_c302;  /*opt-block+*/
23892                                             else 
23893                                               goto MATCH_label_c301;  /*opt-block+*/
23894                                             
23895                                             break;
23896                                           case 5: 
23897                                             goto MATCH_label_c303; break;
23898                                           default: assert(0);
23899                                         } /* (MATCH_w_8_16 & 0x7) 
23900                                               -- r_m at 16 --*/ 
23901                                       break;
23902                                     case 1: 
23903                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
23904                                       if ((MATCH_w_8_16 & 0x7) 
23905                                               /* r_m at 16 */ == 4 && 
23906                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23907                                               /* index at 24 */ && 
23908                                         (MATCH_w_8_24 >> 3 & 0x7) 
23909                                               /* index at 24 */ < 8)) { 
23910                                         unsigned Eaddr = 
23911                                           2 + addressToPC(MATCH_p);
23912                                         unsigned reg = 
23913                                           (MATCH_w_8_16 >> 3 & 0x7) 
23914                                                 /* reg_opcode at 16 */;
23915                                         nextPC = 5 + MATCH_p; 
23916                                         
23917 #line 321 "frontend/machine/pentium/decoder.m"
23918                                         
23919 
23920                                                 stmts = instantiate(pc,  "XCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
23921 
23922                                         
23923 
23924                                         
23925                                         
23926                                         
23927                                       } /*opt-block*//*opt-block+*/
23928                                       else 
23929                                         goto MATCH_label_c301;  /*opt-block+*/
23930                                       
23931                                       break;
23932                                     case 2: 
23933                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
23934                                       if ((MATCH_w_8_16 & 0x7) 
23935                                               /* r_m at 16 */ == 4 && 
23936                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
23937                                               /* index at 24 */ && 
23938                                         (MATCH_w_8_24 >> 3 & 0x7) 
23939                                               /* index at 24 */ < 8)) 
23940                                         goto MATCH_label_c302;  /*opt-block+*/
23941                                       else 
23942                                         goto MATCH_label_c303;  /*opt-block+*/
23943                                       
23944                                       break;
23945                                     case 3: 
23946                                       goto MATCH_label_c300; break;
23947                                     default: assert(0);
23948                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
23949                                         -- mod at 16 --*/ 
23950                                 
23951                               } /*opt-block*/
23952                               break;
23953                             default: assert(0);
23954                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
23955                         break;
23956                       case 9: 
23957                         if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) 
23958                           
23959                             switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
23960                               case 0: 
23961                                 nextPC = 2 + MATCH_p; 
23962                                 
23963 #line 1274 "frontend/machine/pentium/decoder.m"
23964                                 
23965 
23966                                         stmts = instantiate(pc,  "CBW");
23967 
23968                                 
23969 
23970                                     /* Decode the following as a NOP. We see these in startup code, and anywhere
23971 
23972                                         that calls the OS (as lcall 7, 0) */
23973 
23974                                 
23975                                 
23976                                 
23977                                 
23978                                 break;
23979                               case 1: 
23980                                 nextPC = 2 + MATCH_p; 
23981                                 
23982 #line 1229 "frontend/machine/pentium/decoder.m"
23983                                 
23984 
23985                                         stmts = instantiate(pc,  "CWD");
23986 
23987                                 
23988 
23989                                 
23990                                 
23991                                 
23992                                 
23993                                 break;
23994                               case 2: case 3: case 4: case 5: case 6: case 7: 
23995                                 goto MATCH_label_c64; break;
23996                               default: assert(0);
23997                             } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/  
23998                         else { 
23999                           unsigned r32 = (MATCH_w_8_8 & 0x7) /* r32 at 8 */;
24000                           nextPC = 2 + MATCH_p; 
24001                           
24002 #line 351 "frontend/machine/pentium/decoder.m"
24003                           
24004 
24005                                 stmts = instantiate(pc,  "XCHGeAXow", DIS_R32);
24006 
24007                           
24008 
24009                           
24010                           
24011                           
24012                         } /*opt-block*//*opt-block+*/
24013                         break;
24014                       case 10: 
24015                         
24016                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
24017                             case 0: case 2: case 4: case 6: 
24018                               goto MATCH_label_c64; break;
24019                             case 1: 
24020                               if ((MATCH_w_8_8 >> 3 & 0x1) 
24021                                       /* page at 8 */ == 1) { 
24022                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
24023                                 { 
24024                                   unsigned i16 = 
24025                                     (MATCH_w_16_16 & 0xffff) /* i16 at 16 */;
24026                                   nextPC = 4 + MATCH_p; 
24027                                   
24028 #line 399 "frontend/machine/pentium/decoder.m"
24029                                   
24030 
24031                                         stmts = instantiate(pc,  "TEST.eAX.Ivow", DIS_I16);
24032 
24033                                   
24034 
24035                                   
24036                                   
24037                                   
24038                                 }
24039                                 
24040                               } /*opt-block*/
24041                               else { 
24042                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
24043                                 { 
24044                                   unsigned off = 
24045                                     MATCH_w_32_16 /* i32 at 16 */;
24046                                   nextPC = 6 + MATCH_p; 
24047                                   
24048 #line 1010 "frontend/machine/pentium/decoder.m"
24049                                   
24050 
24051                                         stmts = instantiate(pc,  "MOV.eAX.Ovow", DIS_OFF);
24052 
24053                                   
24054 
24055                                   
24056                                   
24057                                   
24058                                 }
24059                                 
24060                               } /*opt-block*/
24061                               
24062                               break;
24063                             case 3: 
24064                               if ((MATCH_w_8_8 >> 3 & 0x1) 
24065                                       /* page at 8 */ == 1) { 
24066                                 nextPC = 2 + MATCH_p; 
24067                                 
24068 #line 411 "frontend/machine/pentium/decoder.m"
24069                                 
24070 
24071                                         stmts = instantiate(pc,  "STOSvow");
24072 
24073                                 
24074 
24075                                 
24076                                 
24077                                 
24078                               } /*opt-block*//*opt-block+*/
24079                               else { 
24080                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
24081                                 { 
24082                                   unsigned off = 
24083                                     MATCH_w_32_16 /* i32 at 16 */;
24084                                   nextPC = 6 + MATCH_p; 
24085                                   
24086 #line 1001 "frontend/machine/pentium/decoder.m"
24087                                   
24088 
24089                                         stmts = instantiate(pc,  "MOV.Ov.eAXow", DIS_OFF);
24090 
24091                                   
24092 
24093                                   
24094                                   
24095                                   
24096                                 }
24097                                 
24098                               } /*opt-block*/
24099                               
24100                               break;
24101                             case 5: 
24102                               if ((MATCH_w_8_8 >> 3 & 0x1) 
24103                                       /* page at 8 */ == 1) { 
24104                                 nextPC = 2 + MATCH_p; 
24105                                 
24106 #line 1747 "frontend/machine/pentium/decoder.m"
24107                                 
24108 
24109                                         stmts = instantiate(pc,  "LODSvow");
24110 
24111                                 
24112 
24113                                 
24114                                 
24115                                 
24116                               } /*opt-block*//*opt-block+*/
24117                               else { 
24118                                 nextPC = 2 + MATCH_p; 
24119                                 
24120 #line 958 "frontend/machine/pentium/decoder.m"
24121                                 
24122 
24123                                         stmts = instantiate(pc,  "MOVSvow");
24124 
24125                                 
24126 
24127                                 
24128                                 
24129                                 
24130                               } /*opt-block*//*opt-block+*/
24131                               
24132                               break;
24133                             case 7: 
24134                               if ((MATCH_w_8_8 >> 3 & 0x1) 
24135                                       /* page at 8 */ == 1) { 
24136                                 nextPC = 2 + MATCH_p; 
24137                                 
24138 #line 466 "frontend/machine/pentium/decoder.m"
24139                                 
24140 
24141                                         stmts = instantiate(pc,  "SCASvow");
24142 
24143                                 
24144 
24145                                 
24146                                 
24147                                 
24148                               } /*opt-block*//*opt-block+*/
24149                               else { 
24150                                 nextPC = 2 + MATCH_p; 
24151                                 
24152 #line 1250 "frontend/machine/pentium/decoder.m"
24153                                 
24154 
24155                                         stmts = instantiate(pc,  "CMPSvow");
24156 
24157                                 
24158 
24159                                 
24160                                 
24161                                 
24162                               } /*opt-block*//*opt-block+*/
24163                               
24164                               break;
24165                             default: assert(0);
24166                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
24167                         break;
24168                       case 11: 
24169                         if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) { 
24170                           MATCH_w_16_16 = getWord(2 + MATCH_p); 
24171                           { 
24172                             int /* [~32768..32767] */ i16 = 
24173                               sign_extend((MATCH_w_16_16 & 0xffff) 
24174                                                 /* i16 at 16 */, 16);
24175                             unsigned r16 = (MATCH_w_8_8 & 0x7) /* r16 at 8 */;
24176                             nextPC = 4 + MATCH_p; 
24177                             
24178 #line 992 "frontend/machine/pentium/decoder.m"
24179                             
24180 
24181                                     stmts = instantiate(pc,  "MOViw", DIS_R16, DIS_I16);  // Check!
24182 
24183                             
24184 
24185                             
24186                             
24187                             
24188                           }
24189                           
24190                         } /*opt-block*/
24191                         else 
24192                           goto MATCH_label_c64;  /*opt-block+*/
24193                         
24194                         break;
24195                       case 12: 
24196                         
24197                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
24198                             case 0: case 2: case 3: case 4: case 5: case 6: 
24199                               goto MATCH_label_c64; break;
24200                             case 1: 
24201                               if ((MATCH_w_8_8 >> 3 & 0x1) 
24202                                       /* page at 8 */ == 1) 
24203                                 goto MATCH_label_c64;  /*opt-block+*/
24204                               else { 
24205                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
24206                                 
24207                                   switch((MATCH_w_8_16 >> 3 & 0x7) 
24208                                         /* reg_opcode at 16 */) {
24209                                     case 0: 
24210                                       
24211                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
24212                                               /* mod at 16 */) {
24213                                           case 0: 
24214                                             
24215                                               switch((MATCH_w_8_16 & 0x7) 
24216                                                     /* r_m at 16 */) {
24217                                                 case 0: case 1: case 2: 
24218                                                 case 3: case 6: case 7: 
24219                                                   MATCH_w_8_24 = 
24220                                                     getByte(3 + MATCH_p); 
24221                                                   goto MATCH_label_c308; 
24222                                                   
24223                                                   break;
24224                                                 case 4: 
24225                                                   MATCH_w_8_24 = 
24226                                                     getByte(3 + MATCH_p); 
24227                                                   if ((MATCH_w_8_24 & 0x7) 
24228                                                           /* base at 24 */ == 5 && 
24229                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24230                                                           /* index at 24 */ && 
24231                                                     (MATCH_w_8_24 >> 3 & 0x7) 
24232                                                           /* index at 24 */ < 8)) { 
24233                                                     MATCH_w_8_64 = 
24234                                                       getByte(8 + MATCH_p); 
24235                                                     goto MATCH_label_c310; 
24236                                                     
24237                                                   } /*opt-block*/
24238                                                   else { 
24239                                                     MATCH_w_8_32 = 
24240                                                       getByte(4 + MATCH_p); 
24241                                                     goto MATCH_label_c309; 
24242                                                     
24243                                                   } /*opt-block*/
24244                                                   
24245                                                   break;
24246                                                 case 5: 
24247                                                   MATCH_w_8_56 = 
24248                                                     getByte(7 + MATCH_p); 
24249                                                   goto MATCH_label_c311; 
24250                                                   
24251                                                   break;
24252                                                 default: assert(0);
24253                                               } /* (MATCH_w_8_16 & 0x7) 
24254                                                     -- r_m at 16 --*/ 
24255                                             break;
24256                                           case 1: 
24257                                             MATCH_w_8_24 = 
24258                                               getByte(3 + MATCH_p); 
24259                                             if ((MATCH_w_8_16 & 0x7) 
24260                                                     /* r_m at 16 */ == 4 && 
24261                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24262                                                     /* index at 24 */ && 
24263                                               (MATCH_w_8_24 >> 3 & 0x7) 
24264                                                     /* index at 24 */ < 8)) { 
24265                                               MATCH_w_8_40 = 
24266                                                 getByte(5 + MATCH_p); 
24267                                               { 
24268                                                 unsigned Eaddr = 
24269                                                   2 + addressToPC(MATCH_p);
24270                                                 int /* [~128..127] */ i8 = 
24271                                                   sign_extend((MATCH_w_8_40 & 0xff) 
24272                                                                     /* i8 at 40 */, 
24273                                                               8);
24274                                                 nextPC = 6 + MATCH_p; 
24275                                                 
24276 #line 638 "frontend/machine/pentium/decoder.m"
24277                                                 
24278 
24279                                                         stmts = instantiate(pc,  "ROLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
24280 
24281                                                 
24282 
24283                                                 
24284                                                 
24285                                                 
24286                                               }
24287                                               
24288                                             } /*opt-block*/
24289                                             else { 
24290                                               MATCH_w_8_32 = 
24291                                                 getByte(4 + MATCH_p); 
24292                                               goto MATCH_label_c309; 
24293                                               
24294                                             } /*opt-block*/
24295                                             
24296                                             break;
24297                                           case 2: 
24298                                             MATCH_w_8_24 = 
24299                                               getByte(3 + MATCH_p); 
24300                                             if ((MATCH_w_8_16 & 0x7) 
24301                                                     /* r_m at 16 */ == 4 && 
24302                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24303                                                     /* index at 24 */ && 
24304                                               (MATCH_w_8_24 >> 3 & 0x7) 
24305                                                     /* index at 24 */ < 8)) { 
24306                                               MATCH_w_8_64 = 
24307                                                 getByte(8 + MATCH_p); 
24308                                               goto MATCH_label_c310; 
24309                                               
24310                                             } /*opt-block*/
24311                                             else { 
24312                                               MATCH_w_8_56 = 
24313                                                 getByte(7 + MATCH_p); 
24314                                               goto MATCH_label_c311; 
24315                                               
24316                                             } /*opt-block*/
24317                                             
24318                                             break;
24319                                           case 3: 
24320                                             MATCH_w_8_24 = 
24321                                               getByte(3 + MATCH_p); 
24322                                             goto MATCH_label_c308; 
24323                                             
24324                                             break;
24325                                           default: assert(0);
24326                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
24327                                               -- mod at 16 --*/ 
24328                                       break;
24329                                     case 1: 
24330                                       
24331                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
24332                                               /* mod at 16 */) {
24333                                           case 0: 
24334                                             
24335                                               switch((MATCH_w_8_16 & 0x7) 
24336                                                     /* r_m at 16 */) {
24337                                                 case 0: case 1: case 2: 
24338                                                 case 3: case 6: case 7: 
24339                                                   MATCH_w_8_24 = 
24340                                                     getByte(3 + MATCH_p); 
24341                                                   goto MATCH_label_c312; 
24342                                                   
24343                                                   break;
24344                                                 case 4: 
24345                                                   MATCH_w_8_24 = 
24346                                                     getByte(3 + MATCH_p); 
24347                                                   if ((MATCH_w_8_24 & 0x7) 
24348                                                           /* base at 24 */ == 5 && 
24349                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24350                                                           /* index at 24 */ && 
24351                                                     (MATCH_w_8_24 >> 3 & 0x7) 
24352                                                           /* index at 24 */ < 8)) { 
24353                                                     MATCH_w_8_64 = 
24354                                                       getByte(8 + MATCH_p); 
24355                                                     goto MATCH_label_c314; 
24356                                                     
24357                                                   } /*opt-block*/
24358                                                   else { 
24359                                                     MATCH_w_8_32 = 
24360                                                       getByte(4 + MATCH_p); 
24361                                                     goto MATCH_label_c313; 
24362                                                     
24363                                                   } /*opt-block*/
24364                                                   
24365                                                   break;
24366                                                 case 5: 
24367                                                   MATCH_w_8_56 = 
24368                                                     getByte(7 + MATCH_p); 
24369                                                   goto MATCH_label_c315; 
24370                                                   
24371                                                   break;
24372                                                 default: assert(0);
24373                                               } /* (MATCH_w_8_16 & 0x7) 
24374                                                     -- r_m at 16 --*/ 
24375                                             break;
24376                                           case 1: 
24377                                             MATCH_w_8_24 = 
24378                                               getByte(3 + MATCH_p); 
24379                                             if ((MATCH_w_8_16 & 0x7) 
24380                                                     /* r_m at 16 */ == 4 && 
24381                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24382                                                     /* index at 24 */ && 
24383                                               (MATCH_w_8_24 >> 3 & 0x7) 
24384                                                     /* index at 24 */ < 8)) { 
24385                                               MATCH_w_8_40 = 
24386                                                 getByte(5 + MATCH_p); 
24387                                               { 
24388                                                 unsigned Eaddr = 
24389                                                   2 + addressToPC(MATCH_p);
24390                                                 int /* [~128..127] */ i8 = 
24391                                                   sign_extend((MATCH_w_8_40 & 0xff) 
24392                                                                     /* i8 at 40 */, 
24393                                                               8);
24394                                                 nextPC = 6 + MATCH_p; 
24395                                                 
24396 #line 632 "frontend/machine/pentium/decoder.m"
24397                                                 
24398 
24399                                                         stmts = instantiate(pc,  "RORB.Ev.Ibow", DIS_EADDR16, DIS_I8);
24400 
24401                                                 
24402 
24403                                                 
24404                                                 
24405                                                 
24406                                               }
24407                                               
24408                                             } /*opt-block*/
24409                                             else { 
24410                                               MATCH_w_8_32 = 
24411                                                 getByte(4 + MATCH_p); 
24412                                               goto MATCH_label_c313; 
24413                                               
24414                                             } /*opt-block*/
24415                                             
24416                                             break;
24417                                           case 2: 
24418                                             MATCH_w_8_24 = 
24419                                               getByte(3 + MATCH_p); 
24420                                             if ((MATCH_w_8_16 & 0x7) 
24421                                                     /* r_m at 16 */ == 4 && 
24422                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24423                                                     /* index at 24 */ && 
24424                                               (MATCH_w_8_24 >> 3 & 0x7) 
24425                                                     /* index at 24 */ < 8)) { 
24426                                               MATCH_w_8_64 = 
24427                                                 getByte(8 + MATCH_p); 
24428                                               goto MATCH_label_c314; 
24429                                               
24430                                             } /*opt-block*/
24431                                             else { 
24432                                               MATCH_w_8_56 = 
24433                                                 getByte(7 + MATCH_p); 
24434                                               goto MATCH_label_c315; 
24435                                               
24436                                             } /*opt-block*/
24437                                             
24438                                             break;
24439                                           case 3: 
24440                                             MATCH_w_8_24 = 
24441                                               getByte(3 + MATCH_p); 
24442                                             goto MATCH_label_c312; 
24443                                             
24444                                             break;
24445                                           default: assert(0);
24446                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
24447                                               -- mod at 16 --*/ 
24448                                       break;
24449                                     case 2: 
24450                                       
24451                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
24452                                               /* mod at 16 */) {
24453                                           case 0: 
24454                                             
24455                                               switch((MATCH_w_8_16 & 0x7) 
24456                                                     /* r_m at 16 */) {
24457                                                 case 0: case 1: case 2: 
24458                                                 case 3: case 6: case 7: 
24459                                                   MATCH_w_8_24 = 
24460                                                     getByte(3 + MATCH_p); 
24461                                                   goto MATCH_label_c316; 
24462                                                   
24463                                                   break;
24464                                                 case 4: 
24465                                                   MATCH_w_8_24 = 
24466                                                     getByte(3 + MATCH_p); 
24467                                                   if ((MATCH_w_8_24 & 0x7) 
24468                                                           /* base at 24 */ == 5 && 
24469                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24470                                                           /* index at 24 */ && 
24471                                                     (MATCH_w_8_24 >> 3 & 0x7) 
24472                                                           /* index at 24 */ < 8)) { 
24473                                                     MATCH_w_8_64 = 
24474                                                       getByte(8 + MATCH_p); 
24475                                                     goto MATCH_label_c318; 
24476                                                     
24477                                                   } /*opt-block*/
24478                                                   else { 
24479                                                     MATCH_w_8_32 = 
24480                                                       getByte(4 + MATCH_p); 
24481                                                     goto MATCH_label_c317; 
24482                                                     
24483                                                   } /*opt-block*/
24484                                                   
24485                                                   break;
24486                                                 case 5: 
24487                                                   MATCH_w_8_56 = 
24488                                                     getByte(7 + MATCH_p); 
24489                                                   goto MATCH_label_c319; 
24490                                                   
24491                                                   break;
24492                                                 default: assert(0);
24493                                               } /* (MATCH_w_8_16 & 0x7) 
24494                                                     -- r_m at 16 --*/ 
24495                                             break;
24496                                           case 1: 
24497                                             MATCH_w_8_24 = 
24498                                               getByte(3 + MATCH_p); 
24499                                             if ((MATCH_w_8_16 & 0x7) 
24500                                                     /* r_m at 16 */ == 4 && 
24501                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24502                                                     /* index at 24 */ && 
24503                                               (MATCH_w_8_24 >> 3 & 0x7) 
24504                                                     /* index at 24 */ < 8)) { 
24505                                               MATCH_w_8_40 = 
24506                                                 getByte(5 + MATCH_p); 
24507                                               { 
24508                                                 unsigned Eaddr = 
24509                                                   2 + addressToPC(MATCH_p);
24510                                                 int /* [~128..127] */ i8 = 
24511                                                   sign_extend((MATCH_w_8_40 & 0xff) 
24512                                                                     /* i8 at 40 */, 
24513                                                               8);
24514                                                 nextPC = 6 + MATCH_p; 
24515                                                 
24516 #line 626 "frontend/machine/pentium/decoder.m"
24517                                                 
24518 
24519                                                         stmts = instantiate(pc,  "RCLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
24520 
24521                                                 
24522 
24523                                                 
24524                                                 
24525                                                 
24526                                               }
24527                                               
24528                                             } /*opt-block*/
24529                                             else { 
24530                                               MATCH_w_8_32 = 
24531                                                 getByte(4 + MATCH_p); 
24532                                               goto MATCH_label_c317; 
24533                                               
24534                                             } /*opt-block*/
24535                                             
24536                                             break;
24537                                           case 2: 
24538                                             MATCH_w_8_24 = 
24539                                               getByte(3 + MATCH_p); 
24540                                             if ((MATCH_w_8_16 & 0x7) 
24541                                                     /* r_m at 16 */ == 4 && 
24542                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24543                                                     /* index at 24 */ && 
24544                                               (MATCH_w_8_24 >> 3 & 0x7) 
24545                                                     /* index at 24 */ < 8)) { 
24546                                               MATCH_w_8_64 = 
24547                                                 getByte(8 + MATCH_p); 
24548                                               goto MATCH_label_c318; 
24549                                               
24550                                             } /*opt-block*/
24551                                             else { 
24552                                               MATCH_w_8_56 = 
24553                                                 getByte(7 + MATCH_p); 
24554                                               goto MATCH_label_c319; 
24555                                               
24556                                             } /*opt-block*/
24557                                             
24558                                             break;
24559                                           case 3: 
24560                                             MATCH_w_8_24 = 
24561                                               getByte(3 + MATCH_p); 
24562                                             goto MATCH_label_c316; 
24563                                             
24564                                             break;
24565                                           default: assert(0);
24566                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
24567                                               -- mod at 16 --*/ 
24568                                       break;
24569                                     case 3: 
24570                                       
24571                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
24572                                               /* mod at 16 */) {
24573                                           case 0: 
24574                                             
24575                                               switch((MATCH_w_8_16 & 0x7) 
24576                                                     /* r_m at 16 */) {
24577                                                 case 0: case 1: case 2: 
24578                                                 case 3: case 6: case 7: 
24579                                                   MATCH_w_8_24 = 
24580                                                     getByte(3 + MATCH_p); 
24581                                                   goto MATCH_label_c320; 
24582                                                   
24583                                                   break;
24584                                                 case 4: 
24585                                                   MATCH_w_8_24 = 
24586                                                     getByte(3 + MATCH_p); 
24587                                                   if ((MATCH_w_8_24 & 0x7) 
24588                                                           /* base at 24 */ == 5 && 
24589                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24590                                                           /* index at 24 */ && 
24591                                                     (MATCH_w_8_24 >> 3 & 0x7) 
24592                                                           /* index at 24 */ < 8)) { 
24593                                                     MATCH_w_8_64 = 
24594                                                       getByte(8 + MATCH_p); 
24595                                                     goto MATCH_label_c322; 
24596                                                     
24597                                                   } /*opt-block*/
24598                                                   else { 
24599                                                     MATCH_w_8_32 = 
24600                                                       getByte(4 + MATCH_p); 
24601                                                     goto MATCH_label_c321; 
24602                                                     
24603                                                   } /*opt-block*/
24604                                                   
24605                                                   break;
24606                                                 case 5: 
24607                                                   MATCH_w_8_56 = 
24608                                                     getByte(7 + MATCH_p); 
24609                                                   goto MATCH_label_c323; 
24610                                                   
24611                                                   break;
24612                                                 default: assert(0);
24613                                               } /* (MATCH_w_8_16 & 0x7) 
24614                                                     -- r_m at 16 --*/ 
24615                                             break;
24616                                           case 1: 
24617                                             MATCH_w_8_24 = 
24618                                               getByte(3 + MATCH_p); 
24619                                             if ((MATCH_w_8_16 & 0x7) 
24620                                                     /* r_m at 16 */ == 4 && 
24621                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24622                                                     /* index at 24 */ && 
24623                                               (MATCH_w_8_24 >> 3 & 0x7) 
24624                                                     /* index at 24 */ < 8)) { 
24625                                               MATCH_w_8_40 = 
24626                                                 getByte(5 + MATCH_p); 
24627                                               { 
24628                                                 unsigned Eaddr = 
24629                                                   2 + addressToPC(MATCH_p);
24630                                                 int /* [~128..127] */ i8 = 
24631                                                   sign_extend((MATCH_w_8_40 & 0xff) 
24632                                                                     /* i8 at 40 */, 
24633                                                               8);
24634                                                 nextPC = 6 + MATCH_p; 
24635                                                 
24636 #line 620 "frontend/machine/pentium/decoder.m"
24637                                                 
24638 
24639                                                         stmts = instantiate(pc,  "RCRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
24640 
24641                                                 
24642 
24643                                                 
24644                                                 
24645                                                 
24646                                               }
24647                                               
24648                                             } /*opt-block*/
24649                                             else { 
24650                                               MATCH_w_8_32 = 
24651                                                 getByte(4 + MATCH_p); 
24652                                               goto MATCH_label_c321; 
24653                                               
24654                                             } /*opt-block*/
24655                                             
24656                                             break;
24657                                           case 2: 
24658                                             MATCH_w_8_24 = 
24659                                               getByte(3 + MATCH_p); 
24660                                             if ((MATCH_w_8_16 & 0x7) 
24661                                                     /* r_m at 16 */ == 4 && 
24662                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24663                                                     /* index at 24 */ && 
24664                                               (MATCH_w_8_24 >> 3 & 0x7) 
24665                                                     /* index at 24 */ < 8)) { 
24666                                               MATCH_w_8_64 = 
24667                                                 getByte(8 + MATCH_p); 
24668                                               goto MATCH_label_c322; 
24669                                               
24670                                             } /*opt-block*/
24671                                             else { 
24672                                               MATCH_w_8_56 = 
24673                                                 getByte(7 + MATCH_p); 
24674                                               goto MATCH_label_c323; 
24675                                               
24676                                             } /*opt-block*/
24677                                             
24678                                             break;
24679                                           case 3: 
24680                                             MATCH_w_8_24 = 
24681                                               getByte(3 + MATCH_p); 
24682                                             goto MATCH_label_c320; 
24683                                             
24684                                             break;
24685                                           default: assert(0);
24686                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
24687                                               -- mod at 16 --*/ 
24688                                       break;
24689                                     case 4: 
24690                                       
24691                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
24692                                               /* mod at 16 */) {
24693                                           case 0: 
24694                                             
24695                                               switch((MATCH_w_8_16 & 0x7) 
24696                                                     /* r_m at 16 */) {
24697                                                 case 0: case 1: case 2: 
24698                                                 case 3: case 6: case 7: 
24699                                                   MATCH_w_8_24 = 
24700                                                     getByte(3 + MATCH_p); 
24701                                                   goto MATCH_label_c324; 
24702                                                   
24703                                                   break;
24704                                                 case 4: 
24705                                                   MATCH_w_8_24 = 
24706                                                     getByte(3 + MATCH_p); 
24707                                                   if ((MATCH_w_8_24 & 0x7) 
24708                                                           /* base at 24 */ == 5 && 
24709                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24710                                                           /* index at 24 */ && 
24711                                                     (MATCH_w_8_24 >> 3 & 0x7) 
24712                                                           /* index at 24 */ < 8)) { 
24713                                                     MATCH_w_8_64 = 
24714                                                       getByte(8 + MATCH_p); 
24715                                                     goto MATCH_label_c326; 
24716                                                     
24717                                                   } /*opt-block*/
24718                                                   else { 
24719                                                     MATCH_w_8_32 = 
24720                                                       getByte(4 + MATCH_p); 
24721                                                     goto MATCH_label_c325; 
24722                                                     
24723                                                   } /*opt-block*/
24724                                                   
24725                                                   break;
24726                                                 case 5: 
24727                                                   MATCH_w_8_56 = 
24728                                                     getByte(7 + MATCH_p); 
24729                                                   goto MATCH_label_c327; 
24730                                                   
24731                                                   break;
24732                                                 default: assert(0);
24733                                               } /* (MATCH_w_8_16 & 0x7) 
24734                                                     -- r_m at 16 --*/ 
24735                                             break;
24736                                           case 1: 
24737                                             MATCH_w_8_24 = 
24738                                               getByte(3 + MATCH_p); 
24739                                             if ((MATCH_w_8_16 & 0x7) 
24740                                                     /* r_m at 16 */ == 4 && 
24741                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24742                                                     /* index at 24 */ && 
24743                                               (MATCH_w_8_24 >> 3 & 0x7) 
24744                                                     /* index at 24 */ < 8)) { 
24745                                               MATCH_w_8_40 = 
24746                                                 getByte(5 + MATCH_p); 
24747                                               { 
24748                                                 unsigned Eaddr = 
24749                                                   2 + addressToPC(MATCH_p);
24750                                                 int /* [~128..127] */ i8 = 
24751                                                   sign_extend((MATCH_w_8_40 & 0xff) 
24752                                                                     /* i8 at 40 */, 
24753                                                               8);
24754                                                 nextPC = 6 + MATCH_p; 
24755                                                 
24756 #line 614 "frontend/machine/pentium/decoder.m"
24757                                                 
24758 
24759                                                         stmts = instantiate(pc,  "SHLSALB.Ev.Ibow", DIS_EADDR16, DIS_I8);
24760 
24761                                                 
24762 
24763                                                 
24764                                                 
24765                                                 
24766                                               }
24767                                               
24768                                             } /*opt-block*/
24769                                             else { 
24770                                               MATCH_w_8_32 = 
24771                                                 getByte(4 + MATCH_p); 
24772                                               goto MATCH_label_c325; 
24773                                               
24774                                             } /*opt-block*/
24775                                             
24776                                             break;
24777                                           case 2: 
24778                                             MATCH_w_8_24 = 
24779                                               getByte(3 + MATCH_p); 
24780                                             if ((MATCH_w_8_16 & 0x7) 
24781                                                     /* r_m at 16 */ == 4 && 
24782                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24783                                                     /* index at 24 */ && 
24784                                               (MATCH_w_8_24 >> 3 & 0x7) 
24785                                                     /* index at 24 */ < 8)) { 
24786                                               MATCH_w_8_64 = 
24787                                                 getByte(8 + MATCH_p); 
24788                                               goto MATCH_label_c326; 
24789                                               
24790                                             } /*opt-block*/
24791                                             else { 
24792                                               MATCH_w_8_56 = 
24793                                                 getByte(7 + MATCH_p); 
24794                                               goto MATCH_label_c327; 
24795                                               
24796                                             } /*opt-block*/
24797                                             
24798                                             break;
24799                                           case 3: 
24800                                             MATCH_w_8_24 = 
24801                                               getByte(3 + MATCH_p); 
24802                                             goto MATCH_label_c324; 
24803                                             
24804                                             break;
24805                                           default: assert(0);
24806                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
24807                                               -- mod at 16 --*/ 
24808                                       break;
24809                                     case 5: 
24810                                       
24811                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
24812                                               /* mod at 16 */) {
24813                                           case 0: 
24814                                             
24815                                               switch((MATCH_w_8_16 & 0x7) 
24816                                                     /* r_m at 16 */) {
24817                                                 case 0: case 1: case 2: 
24818                                                 case 3: case 6: case 7: 
24819                                                   MATCH_w_8_24 = 
24820                                                     getByte(3 + MATCH_p); 
24821                                                   goto MATCH_label_c328; 
24822                                                   
24823                                                   break;
24824                                                 case 4: 
24825                                                   MATCH_w_8_24 = 
24826                                                     getByte(3 + MATCH_p); 
24827                                                   if ((MATCH_w_8_24 & 0x7) 
24828                                                           /* base at 24 */ == 5 && 
24829                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24830                                                           /* index at 24 */ && 
24831                                                     (MATCH_w_8_24 >> 3 & 0x7) 
24832                                                           /* index at 24 */ < 8)) { 
24833                                                     MATCH_w_8_64 = 
24834                                                       getByte(8 + MATCH_p); 
24835                                                     goto MATCH_label_c330; 
24836                                                     
24837                                                   } /*opt-block*/
24838                                                   else { 
24839                                                     MATCH_w_8_32 = 
24840                                                       getByte(4 + MATCH_p); 
24841                                                     goto MATCH_label_c329; 
24842                                                     
24843                                                   } /*opt-block*/
24844                                                   
24845                                                   break;
24846                                                 case 5: 
24847                                                   MATCH_w_8_56 = 
24848                                                     getByte(7 + MATCH_p); 
24849                                                   goto MATCH_label_c331; 
24850                                                   
24851                                                   break;
24852                                                 default: assert(0);
24853                                               } /* (MATCH_w_8_16 & 0x7) 
24854                                                     -- r_m at 16 --*/ 
24855                                             break;
24856                                           case 1: 
24857                                             MATCH_w_8_24 = 
24858                                               getByte(3 + MATCH_p); 
24859                                             if ((MATCH_w_8_16 & 0x7) 
24860                                                     /* r_m at 16 */ == 4 && 
24861                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24862                                                     /* index at 24 */ && 
24863                                               (MATCH_w_8_24 >> 3 & 0x7) 
24864                                                     /* index at 24 */ < 8)) { 
24865                                               MATCH_w_8_40 = 
24866                                                 getByte(5 + MATCH_p); 
24867                                               { 
24868                                                 unsigned Eaddr = 
24869                                                   2 + addressToPC(MATCH_p);
24870                                                 int /* [~128..127] */ i8 = 
24871                                                   sign_extend((MATCH_w_8_40 & 0xff) 
24872                                                                     /* i8 at 40 */, 
24873                                                               8);
24874                                                 nextPC = 6 + MATCH_p; 
24875                                                 
24876 #line 608 "frontend/machine/pentium/decoder.m"
24877                                                 
24878 
24879                                                         stmts = instantiate(pc,  "SHRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
24880 
24881                                                 
24882 
24883                                                 
24884                                                 
24885                                                 
24886                                               }
24887                                               
24888                                             } /*opt-block*/
24889                                             else { 
24890                                               MATCH_w_8_32 = 
24891                                                 getByte(4 + MATCH_p); 
24892                                               goto MATCH_label_c329; 
24893                                               
24894                                             } /*opt-block*/
24895                                             
24896                                             break;
24897                                           case 2: 
24898                                             MATCH_w_8_24 = 
24899                                               getByte(3 + MATCH_p); 
24900                                             if ((MATCH_w_8_16 & 0x7) 
24901                                                     /* r_m at 16 */ == 4 && 
24902                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24903                                                     /* index at 24 */ && 
24904                                               (MATCH_w_8_24 >> 3 & 0x7) 
24905                                                     /* index at 24 */ < 8)) { 
24906                                               MATCH_w_8_64 = 
24907                                                 getByte(8 + MATCH_p); 
24908                                               goto MATCH_label_c330; 
24909                                               
24910                                             } /*opt-block*/
24911                                             else { 
24912                                               MATCH_w_8_56 = 
24913                                                 getByte(7 + MATCH_p); 
24914                                               goto MATCH_label_c331; 
24915                                               
24916                                             } /*opt-block*/
24917                                             
24918                                             break;
24919                                           case 3: 
24920                                             MATCH_w_8_24 = 
24921                                               getByte(3 + MATCH_p); 
24922                                             goto MATCH_label_c328; 
24923                                             
24924                                             break;
24925                                           default: assert(0);
24926                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
24927                                               -- mod at 16 --*/ 
24928                                       break;
24929                                     case 6: 
24930                                       goto MATCH_label_c64; break;
24931                                     case 7: 
24932                                       
24933                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
24934                                               /* mod at 16 */) {
24935                                           case 0: 
24936                                             
24937                                               switch((MATCH_w_8_16 & 0x7) 
24938                                                     /* r_m at 16 */) {
24939                                                 case 0: case 1: case 2: 
24940                                                 case 3: case 6: case 7: 
24941                                                   MATCH_w_8_24 = 
24942                                                     getByte(3 + MATCH_p); 
24943                                                   goto MATCH_label_c332; 
24944                                                   
24945                                                   break;
24946                                                 case 4: 
24947                                                   MATCH_w_8_24 = 
24948                                                     getByte(3 + MATCH_p); 
24949                                                   if ((MATCH_w_8_24 & 0x7) 
24950                                                           /* base at 24 */ == 5 && 
24951                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24952                                                           /* index at 24 */ && 
24953                                                     (MATCH_w_8_24 >> 3 & 0x7) 
24954                                                           /* index at 24 */ < 8)) { 
24955                                                     MATCH_w_8_64 = 
24956                                                       getByte(8 + MATCH_p); 
24957                                                     goto MATCH_label_c334; 
24958                                                     
24959                                                   } /*opt-block*/
24960                                                   else { 
24961                                                     MATCH_w_8_32 = 
24962                                                       getByte(4 + MATCH_p); 
24963                                                     goto MATCH_label_c333; 
24964                                                     
24965                                                   } /*opt-block*/
24966                                                   
24967                                                   break;
24968                                                 case 5: 
24969                                                   MATCH_w_8_56 = 
24970                                                     getByte(7 + MATCH_p); 
24971                                                   goto MATCH_label_c335; 
24972                                                   
24973                                                   break;
24974                                                 default: assert(0);
24975                                               } /* (MATCH_w_8_16 & 0x7) 
24976                                                     -- r_m at 16 --*/ 
24977                                             break;
24978                                           case 1: 
24979                                             MATCH_w_8_24 = 
24980                                               getByte(3 + MATCH_p); 
24981                                             if ((MATCH_w_8_16 & 0x7) 
24982                                                     /* r_m at 16 */ == 4 && 
24983                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
24984                                                     /* index at 24 */ && 
24985                                               (MATCH_w_8_24 >> 3 & 0x7) 
24986                                                     /* index at 24 */ < 8)) { 
24987                                               MATCH_w_8_40 = 
24988                                                 getByte(5 + MATCH_p); 
24989                                               { 
24990                                                 unsigned Eaddr = 
24991                                                   2 + addressToPC(MATCH_p);
24992                                                 int /* [~128..127] */ i8 = 
24993                                                   sign_extend((MATCH_w_8_40 & 0xff) 
24994                                                                     /* i8 at 40 */, 
24995                                                               8);
24996                                                 nextPC = 6 + MATCH_p; 
24997                                                 
24998 #line 602 "frontend/machine/pentium/decoder.m"
24999                                                 
25000 
25001                                                         stmts = instantiate(pc,  "SARB.Ev.Ibow", DIS_EADDR16, DIS_I8);
25002 
25003                                                 
25004 
25005                                                 
25006                                                 
25007                                                 
25008                                               }
25009                                               
25010                                             } /*opt-block*/
25011                                             else { 
25012                                               MATCH_w_8_32 = 
25013                                                 getByte(4 + MATCH_p); 
25014                                               goto MATCH_label_c333; 
25015                                               
25016                                             } /*opt-block*/
25017                                             
25018                                             break;
25019                                           case 2: 
25020                                             MATCH_w_8_24 = 
25021                                               getByte(3 + MATCH_p); 
25022                                             if ((MATCH_w_8_16 & 0x7) 
25023                                                     /* r_m at 16 */ == 4 && 
25024                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25025                                                     /* index at 24 */ && 
25026                                               (MATCH_w_8_24 >> 3 & 0x7) 
25027                                                     /* index at 24 */ < 8)) { 
25028                                               MATCH_w_8_64 = 
25029                                                 getByte(8 + MATCH_p); 
25030                                               goto MATCH_label_c334; 
25031                                               
25032                                             } /*opt-block*/
25033                                             else { 
25034                                               MATCH_w_8_56 = 
25035                                                 getByte(7 + MATCH_p); 
25036                                               goto MATCH_label_c335; 
25037                                               
25038                                             } /*opt-block*/
25039                                             
25040                                             break;
25041                                           case 3: 
25042                                             MATCH_w_8_24 = 
25043                                               getByte(3 + MATCH_p); 
25044                                             goto MATCH_label_c332; 
25045                                             
25046                                             break;
25047                                           default: assert(0);
25048                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
25049                                               -- mod at 16 --*/ 
25050                                       break;
25051                                     default: assert(0);
25052                                   } /* (MATCH_w_8_16 >> 3 & 0x7) 
25053                                         -- reg_opcode at 16 --*/ 
25054                                 
25055                               } /*opt-block*/
25056                               break;
25057                             case 7: 
25058                               if ((MATCH_w_8_8 >> 3 & 0x1) 
25059                                       /* page at 8 */ == 1) 
25060                                 goto MATCH_label_c64;  /*opt-block+*/
25061                               else { 
25062                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
25063                                 if ((MATCH_w_8_16 >> 3 & 0x7) 
25064                                         /* reg_opcode at 16 */ == 0) 
25065                                   
25066                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
25067                                           /* mod at 16 */) {
25068                                       case 0: 
25069                                         
25070                                           switch((MATCH_w_8_16 & 0x7) 
25071                                                 /* r_m at 16 */) {
25072                                             case 0: case 1: case 2: case 3: 
25073                                             case 6: case 7: 
25074                                               MATCH_w_16_24 = 
25075                                                 getWord(3 + MATCH_p); 
25076                                               goto MATCH_label_c336; 
25077                                               
25078                                               break;
25079                                             case 4: 
25080                                               MATCH_w_8_24 = 
25081                                                 getByte(3 + MATCH_p); 
25082                                               if ((MATCH_w_8_24 & 0x7) 
25083                                                       /* base at 24 */ == 5 && 
25084                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25085                                                       /* index at 24 */ && 
25086                                                 (MATCH_w_8_24 >> 3 & 0x7) 
25087                                                       /* index at 24 */ < 8)) { 
25088                                                 MATCH_w_16_64 = 
25089                                                   getWord(8 + MATCH_p); 
25090                                                 goto MATCH_label_c338; 
25091                                                 
25092                                               } /*opt-block*/
25093                                               else { 
25094                                                 MATCH_w_16_32 = 
25095                                                   getWord(4 + MATCH_p); 
25096                                                 goto MATCH_label_c337; 
25097                                                 
25098                                               } /*opt-block*/
25099                                               
25100                                               break;
25101                                             case 5: 
25102                                               MATCH_w_16_56 = 
25103                                                 getWord(7 + MATCH_p); 
25104                                               goto MATCH_label_c339; 
25105                                               
25106                                               break;
25107                                             default: assert(0);
25108                                           } /* (MATCH_w_8_16 & 0x7) 
25109                                                 -- r_m at 16 --*/ 
25110                                         break;
25111                                       case 1: 
25112                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
25113                                         if ((MATCH_w_8_16 & 0x7) 
25114                                                 /* r_m at 16 */ == 4 && 
25115                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25116                                                 /* index at 24 */ && 
25117                                           (MATCH_w_8_24 >> 3 & 0x7) 
25118                                                 /* index at 24 */ < 8)) { 
25119                                           MATCH_w_16_40 = 
25120                                             getWord(5 + MATCH_p); 
25121                                           { 
25122                                             unsigned Eaddr = 
25123                                               2 + addressToPC(MATCH_p);
25124                                             int /* [~32768..32767] */ i16 = 
25125                                               sign_extend((MATCH_w_16_40 & 0xffff) 
25126                                                                 /* i16 at 40 */, 
25127                                                           16);
25128                                             nextPC = 7 + MATCH_p; 
25129                                             
25130 #line 983 "frontend/machine/pentium/decoder.m"
25131                                             
25132 
25133                                                     stmts = instantiate(pc,  "MOV.Ew.Ivow", DIS_EADDR16, DIS_I16);
25134 
25135                                             
25136 
25137                                             
25138                                             
25139                                             
25140                                           }
25141                                           
25142                                         } /*opt-block*/
25143                                         else { 
25144                                           MATCH_w_16_32 = 
25145                                             getWord(4 + MATCH_p); 
25146                                           goto MATCH_label_c337; 
25147                                           
25148                                         } /*opt-block*/
25149                                         
25150                                         break;
25151                                       case 2: 
25152                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
25153                                         if ((MATCH_w_8_16 & 0x7) 
25154                                                 /* r_m at 16 */ == 4 && 
25155                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25156                                                 /* index at 24 */ && 
25157                                           (MATCH_w_8_24 >> 3 & 0x7) 
25158                                                 /* index at 24 */ < 8)) { 
25159                                           MATCH_w_16_64 = 
25160                                             getWord(8 + MATCH_p); 
25161                                           goto MATCH_label_c338; 
25162                                           
25163                                         } /*opt-block*/
25164                                         else { 
25165                                           MATCH_w_16_56 = 
25166                                             getWord(7 + MATCH_p); 
25167                                           goto MATCH_label_c339; 
25168                                           
25169                                         } /*opt-block*/
25170                                         
25171                                         break;
25172                                       case 3: 
25173                                         MATCH_w_16_24 = getWord(3 + MATCH_p); 
25174                                         goto MATCH_label_c336; 
25175                                         
25176                                         break;
25177                                       default: assert(0);
25178                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
25179                                           -- mod at 16 --*/  
25180                                 else 
25181                                   goto MATCH_label_c64;  /*opt-block+*/
25182                                 
25183                               } /*opt-block*/
25184                               break;
25185                             default: assert(0);
25186                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
25187                         break;
25188                       case 13: 
25189                         
25190                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
25191                             case 0: case 2: case 4: case 5: case 6: case 7: 
25192                               goto MATCH_label_c64; break;
25193                             case 1: 
25194                               if ((MATCH_w_8_8 >> 3 & 0x1) 
25195                                       /* page at 8 */ == 1) 
25196                                 goto MATCH_label_c64;  /*opt-block+*/
25197                               else { 
25198                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
25199                                 
25200                                   switch((MATCH_w_8_16 >> 3 & 0x7) 
25201                                         /* reg_opcode at 16 */) {
25202                                     case 0: 
25203                                       
25204                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
25205                                               /* mod at 16 */) {
25206                                           case 0: 
25207                                             
25208                                               switch((MATCH_w_8_16 & 0x7) 
25209                                                     /* r_m at 16 */) {
25210                                                 case 0: case 1: case 2: 
25211                                                 case 3: case 6: case 7: 
25212                                                   goto MATCH_label_c340; 
25213                                                   
25214                                                   break;
25215                                                 case 4: 
25216                                                   MATCH_w_8_24 = 
25217                                                     getByte(3 + MATCH_p); 
25218                                                   if ((MATCH_w_8_24 & 0x7) 
25219                                                           /* base at 24 */ == 5 && 
25220                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25221                                                           /* index at 24 */ && 
25222                                                     (MATCH_w_8_24 >> 3 & 0x7) 
25223                                                           /* index at 24 */ < 8)) 
25224                                                     goto MATCH_label_c342;  /*opt-block+*/
25225                                                   else 
25226                                                     goto MATCH_label_c341;  /*opt-block+*/
25227                                                   
25228                                                   break;
25229                                                 case 5: 
25230                                                   goto MATCH_label_c343; 
25231                                                   
25232                                                   break;
25233                                                 default: assert(0);
25234                                               } /* (MATCH_w_8_16 & 0x7) 
25235                                                     -- r_m at 16 --*/ 
25236                                             break;
25237                                           case 1: 
25238                                             MATCH_w_8_24 = 
25239                                               getByte(3 + MATCH_p); 
25240                                             if ((MATCH_w_8_16 & 0x7) 
25241                                                     /* r_m at 16 */ == 4 && 
25242                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25243                                                     /* index at 24 */ && 
25244                                               (MATCH_w_8_24 >> 3 & 0x7) 
25245                                                     /* index at 24 */ < 8)) { 
25246                                               unsigned Eaddr = 
25247                                                 2 + addressToPC(MATCH_p);
25248                                               nextPC = 5 + MATCH_p; 
25249                                               
25250 #line 743 "frontend/machine/pentium/decoder.m"
25251                                               
25252 
25253                                                     stmts = instantiate(pc,  "ROLB.Ev.1ow", DIS_EADDR16);
25254 
25255                                               
25256 
25257                                               
25258                                               
25259                                               
25260                                             } /*opt-block*//*opt-block+*/
25261                                             else 
25262                                               goto MATCH_label_c341;  /*opt-block+*/
25263                                             
25264                                             break;
25265                                           case 2: 
25266                                             MATCH_w_8_24 = 
25267                                               getByte(3 + MATCH_p); 
25268                                             if ((MATCH_w_8_16 & 0x7) 
25269                                                     /* r_m at 16 */ == 4 && 
25270                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25271                                                     /* index at 24 */ && 
25272                                               (MATCH_w_8_24 >> 3 & 0x7) 
25273                                                     /* index at 24 */ < 8)) 
25274                                               goto MATCH_label_c342;  /*opt-block+*/
25275                                             else 
25276                                               goto MATCH_label_c343;  /*opt-block+*/
25277                                             
25278                                             break;
25279                                           case 3: 
25280                                             goto MATCH_label_c340; break;
25281                                           default: assert(0);
25282                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
25283                                               -- mod at 16 --*/ 
25284                                       break;
25285                                     case 1: 
25286                                       
25287                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
25288                                               /* mod at 16 */) {
25289                                           case 0: 
25290                                             
25291                                               switch((MATCH_w_8_16 & 0x7) 
25292                                                     /* r_m at 16 */) {
25293                                                 case 0: case 1: case 2: 
25294                                                 case 3: case 6: case 7: 
25295                                                   goto MATCH_label_c344; 
25296                                                   
25297                                                   break;
25298                                                 case 4: 
25299                                                   MATCH_w_8_24 = 
25300                                                     getByte(3 + MATCH_p); 
25301                                                   if ((MATCH_w_8_24 & 0x7) 
25302                                                           /* base at 24 */ == 5 && 
25303                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25304                                                           /* index at 24 */ && 
25305                                                     (MATCH_w_8_24 >> 3 & 0x7) 
25306                                                           /* index at 24 */ < 8)) 
25307                                                     goto MATCH_label_c346;  /*opt-block+*/
25308                                                   else 
25309                                                     goto MATCH_label_c345;  /*opt-block+*/
25310                                                   
25311                                                   break;
25312                                                 case 5: 
25313                                                   goto MATCH_label_c347; 
25314                                                   
25315                                                   break;
25316                                                 default: assert(0);
25317                                               } /* (MATCH_w_8_16 & 0x7) 
25318                                                     -- r_m at 16 --*/ 
25319                                             break;
25320                                           case 1: 
25321                                             MATCH_w_8_24 = 
25322                                               getByte(3 + MATCH_p); 
25323                                             if ((MATCH_w_8_16 & 0x7) 
25324                                                     /* r_m at 16 */ == 4 && 
25325                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25326                                                     /* index at 24 */ && 
25327                                               (MATCH_w_8_24 >> 3 & 0x7) 
25328                                                     /* index at 24 */ < 8)) { 
25329                                               unsigned Eaddr = 
25330                                                 2 + addressToPC(MATCH_p);
25331                                               nextPC = 5 + MATCH_p; 
25332                                               
25333 #line 731 "frontend/machine/pentium/decoder.m"
25334                                               
25335 
25336                                                     stmts = instantiate(pc,  "ORB.Ev.1owR", DIS_EADDR16);
25337 
25338                                               
25339 
25340                                               
25341                                               
25342                                               
25343                                             } /*opt-block*//*opt-block+*/
25344                                             else 
25345                                               goto MATCH_label_c345;  /*opt-block+*/
25346                                             
25347                                             break;
25348                                           case 2: 
25349                                             MATCH_w_8_24 = 
25350                                               getByte(3 + MATCH_p); 
25351                                             if ((MATCH_w_8_16 & 0x7) 
25352                                                     /* r_m at 16 */ == 4 && 
25353                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25354                                                     /* index at 24 */ && 
25355                                               (MATCH_w_8_24 >> 3 & 0x7) 
25356                                                     /* index at 24 */ < 8)) 
25357                                               goto MATCH_label_c346;  /*opt-block+*/
25358                                             else 
25359                                               goto MATCH_label_c347;  /*opt-block+*/
25360                                             
25361                                             break;
25362                                           case 3: 
25363                                             goto MATCH_label_c344; break;
25364                                           default: assert(0);
25365                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
25366                                               -- mod at 16 --*/ 
25367                                       break;
25368                                     case 2: 
25369                                       
25370                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
25371                                               /* mod at 16 */) {
25372                                           case 0: 
25373                                             
25374                                               switch((MATCH_w_8_16 & 0x7) 
25375                                                     /* r_m at 16 */) {
25376                                                 case 0: case 1: case 2: 
25377                                                 case 3: case 6: case 7: 
25378                                                   goto MATCH_label_c348; 
25379                                                   
25380                                                   break;
25381                                                 case 4: 
25382                                                   MATCH_w_8_24 = 
25383                                                     getByte(3 + MATCH_p); 
25384                                                   if ((MATCH_w_8_24 & 0x7) 
25385                                                           /* base at 24 */ == 5 && 
25386                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25387                                                           /* index at 24 */ && 
25388                                                     (MATCH_w_8_24 >> 3 & 0x7) 
25389                                                           /* index at 24 */ < 8)) 
25390                                                     goto MATCH_label_c350;  /*opt-block+*/
25391                                                   else 
25392                                                     goto MATCH_label_c349;  /*opt-block+*/
25393                                                   
25394                                                   break;
25395                                                 case 5: 
25396                                                   goto MATCH_label_c351; 
25397                                                   
25398                                                   break;
25399                                                 default: assert(0);
25400                                               } /* (MATCH_w_8_16 & 0x7) 
25401                                                     -- r_m at 16 --*/ 
25402                                             break;
25403                                           case 1: 
25404                                             MATCH_w_8_24 = 
25405                                               getByte(3 + MATCH_p); 
25406                                             if ((MATCH_w_8_16 & 0x7) 
25407                                                     /* r_m at 16 */ == 4 && 
25408                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25409                                                     /* index at 24 */ && 
25410                                               (MATCH_w_8_24 >> 3 & 0x7) 
25411                                                     /* index at 24 */ < 8)) { 
25412                                               unsigned Eaddr = 
25413                                                 2 + addressToPC(MATCH_p);
25414                                               nextPC = 5 + MATCH_p; 
25415                                               
25416 #line 719 "frontend/machine/pentium/decoder.m"
25417                                               
25418 
25419                                                     stmts = instantiate(pc,  "RCLB.Ev.1ow", DIS_EADDR16);
25420 
25421                                               
25422 
25423                                               
25424                                               
25425                                               
25426                                             } /*opt-block*//*opt-block+*/
25427                                             else 
25428                                               goto MATCH_label_c349;  /*opt-block+*/
25429                                             
25430                                             break;
25431                                           case 2: 
25432                                             MATCH_w_8_24 = 
25433                                               getByte(3 + MATCH_p); 
25434                                             if ((MATCH_w_8_16 & 0x7) 
25435                                                     /* r_m at 16 */ == 4 && 
25436                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25437                                                     /* index at 24 */ && 
25438                                               (MATCH_w_8_24 >> 3 & 0x7) 
25439                                                     /* index at 24 */ < 8)) 
25440                                               goto MATCH_label_c350;  /*opt-block+*/
25441                                             else 
25442                                               goto MATCH_label_c351;  /*opt-block+*/
25443                                             
25444                                             break;
25445                                           case 3: 
25446                                             goto MATCH_label_c348; break;
25447                                           default: assert(0);
25448                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
25449                                               -- mod at 16 --*/ 
25450                                       break;
25451                                     case 3: 
25452                                       
25453                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
25454                                               /* mod at 16 */) {
25455                                           case 0: 
25456                                             
25457                                               switch((MATCH_w_8_16 & 0x7) 
25458                                                     /* r_m at 16 */) {
25459                                                 case 0: case 1: case 2: 
25460                                                 case 3: case 6: case 7: 
25461                                                   goto MATCH_label_c352; 
25462                                                   
25463                                                   break;
25464                                                 case 4: 
25465                                                   MATCH_w_8_24 = 
25466                                                     getByte(3 + MATCH_p); 
25467                                                   if ((MATCH_w_8_24 & 0x7) 
25468                                                           /* base at 24 */ == 5 && 
25469                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25470                                                           /* index at 24 */ && 
25471                                                     (MATCH_w_8_24 >> 3 & 0x7) 
25472                                                           /* index at 24 */ < 8)) 
25473                                                     goto MATCH_label_c354;  /*opt-block+*/
25474                                                   else 
25475                                                     goto MATCH_label_c353;  /*opt-block+*/
25476                                                   
25477                                                   break;
25478                                                 case 5: 
25479                                                   goto MATCH_label_c355; 
25480                                                   
25481                                                   break;
25482                                                 default: assert(0);
25483                                               } /* (MATCH_w_8_16 & 0x7) 
25484                                                     -- r_m at 16 --*/ 
25485                                             break;
25486                                           case 1: 
25487                                             MATCH_w_8_24 = 
25488                                               getByte(3 + MATCH_p); 
25489                                             if ((MATCH_w_8_16 & 0x7) 
25490                                                     /* r_m at 16 */ == 4 && 
25491                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25492                                                     /* index at 24 */ && 
25493                                               (MATCH_w_8_24 >> 3 & 0x7) 
25494                                                     /* index at 24 */ < 8)) { 
25495                                               unsigned Eaddr = 
25496                                                 2 + addressToPC(MATCH_p);
25497                                               nextPC = 5 + MATCH_p; 
25498                                               
25499 #line 707 "frontend/machine/pentium/decoder.m"
25500                                               
25501 
25502                                                     stmts = instantiate(pc,  "RCRB.Ev.1ow", DIS_EADDR16);
25503 
25504                                               
25505 
25506                                               
25507                                               
25508                                               
25509                                             } /*opt-block*//*opt-block+*/
25510                                             else 
25511                                               goto MATCH_label_c353;  /*opt-block+*/
25512                                             
25513                                             break;
25514                                           case 2: 
25515                                             MATCH_w_8_24 = 
25516                                               getByte(3 + MATCH_p); 
25517                                             if ((MATCH_w_8_16 & 0x7) 
25518                                                     /* r_m at 16 */ == 4 && 
25519                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25520                                                     /* index at 24 */ && 
25521                                               (MATCH_w_8_24 >> 3 & 0x7) 
25522                                                     /* index at 24 */ < 8)) 
25523                                               goto MATCH_label_c354;  /*opt-block+*/
25524                                             else 
25525                                               goto MATCH_label_c355;  /*opt-block+*/
25526                                             
25527                                             break;
25528                                           case 3: 
25529                                             goto MATCH_label_c352; break;
25530                                           default: assert(0);
25531                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
25532                                               -- mod at 16 --*/ 
25533                                       break;
25534                                     case 4: 
25535                                       
25536                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
25537                                               /* mod at 16 */) {
25538                                           case 0: 
25539                                             
25540                                               switch((MATCH_w_8_16 & 0x7) 
25541                                                     /* r_m at 16 */) {
25542                                                 case 0: case 1: case 2: 
25543                                                 case 3: case 6: case 7: 
25544                                                   goto MATCH_label_c356; 
25545                                                   
25546                                                   break;
25547                                                 case 4: 
25548                                                   MATCH_w_8_24 = 
25549                                                     getByte(3 + MATCH_p); 
25550                                                   if ((MATCH_w_8_24 & 0x7) 
25551                                                           /* base at 24 */ == 5 && 
25552                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25553                                                           /* index at 24 */ && 
25554                                                     (MATCH_w_8_24 >> 3 & 0x7) 
25555                                                           /* index at 24 */ < 8)) 
25556                                                     goto MATCH_label_c358;  /*opt-block+*/
25557                                                   else 
25558                                                     goto MATCH_label_c357;  /*opt-block+*/
25559                                                   
25560                                                   break;
25561                                                 case 5: 
25562                                                   goto MATCH_label_c359; 
25563                                                   
25564                                                   break;
25565                                                 default: assert(0);
25566                                               } /* (MATCH_w_8_16 & 0x7) 
25567                                                     -- r_m at 16 --*/ 
25568                                             break;
25569                                           case 1: 
25570                                             MATCH_w_8_24 = 
25571                                               getByte(3 + MATCH_p); 
25572                                             if ((MATCH_w_8_16 & 0x7) 
25573                                                     /* r_m at 16 */ == 4 && 
25574                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25575                                                     /* index at 24 */ && 
25576                                               (MATCH_w_8_24 >> 3 & 0x7) 
25577                                                     /* index at 24 */ < 8)) { 
25578                                               unsigned Eaddr = 
25579                                                 2 + addressToPC(MATCH_p);
25580                                               nextPC = 5 + MATCH_p; 
25581                                               
25582 #line 695 "frontend/machine/pentium/decoder.m"
25583                                               
25584 
25585                                                     stmts = instantiate(pc,  "SHLSALB.Ev.1ow", DIS_EADDR16);
25586 
25587                                               
25588 
25589                                               
25590                                               
25591                                               
25592                                             } /*opt-block*//*opt-block+*/
25593                                             else 
25594                                               goto MATCH_label_c357;  /*opt-block+*/
25595                                             
25596                                             break;
25597                                           case 2: 
25598                                             MATCH_w_8_24 = 
25599                                               getByte(3 + MATCH_p); 
25600                                             if ((MATCH_w_8_16 & 0x7) 
25601                                                     /* r_m at 16 */ == 4 && 
25602                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25603                                                     /* index at 24 */ && 
25604                                               (MATCH_w_8_24 >> 3 & 0x7) 
25605                                                     /* index at 24 */ < 8)) 
25606                                               goto MATCH_label_c358;  /*opt-block+*/
25607                                             else 
25608                                               goto MATCH_label_c359;  /*opt-block+*/
25609                                             
25610                                             break;
25611                                           case 3: 
25612                                             goto MATCH_label_c356; break;
25613                                           default: assert(0);
25614                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
25615                                               -- mod at 16 --*/ 
25616                                       break;
25617                                     case 5: 
25618                                       
25619                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
25620                                               /* mod at 16 */) {
25621                                           case 0: 
25622                                             
25623                                               switch((MATCH_w_8_16 & 0x7) 
25624                                                     /* r_m at 16 */) {
25625                                                 case 0: case 1: case 2: 
25626                                                 case 3: case 6: case 7: 
25627                                                   goto MATCH_label_c360; 
25628                                                   
25629                                                   break;
25630                                                 case 4: 
25631                                                   MATCH_w_8_24 = 
25632                                                     getByte(3 + MATCH_p); 
25633                                                   if ((MATCH_w_8_24 & 0x7) 
25634                                                           /* base at 24 */ == 5 && 
25635                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25636                                                           /* index at 24 */ && 
25637                                                     (MATCH_w_8_24 >> 3 & 0x7) 
25638                                                           /* index at 24 */ < 8)) 
25639                                                     goto MATCH_label_c362;  /*opt-block+*/
25640                                                   else 
25641                                                     goto MATCH_label_c361;  /*opt-block+*/
25642                                                   
25643                                                   break;
25644                                                 case 5: 
25645                                                   goto MATCH_label_c363; 
25646                                                   
25647                                                   break;
25648                                                 default: assert(0);
25649                                               } /* (MATCH_w_8_16 & 0x7) 
25650                                                     -- r_m at 16 --*/ 
25651                                             break;
25652                                           case 1: 
25653                                             MATCH_w_8_24 = 
25654                                               getByte(3 + MATCH_p); 
25655                                             if ((MATCH_w_8_16 & 0x7) 
25656                                                     /* r_m at 16 */ == 4 && 
25657                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25658                                                     /* index at 24 */ && 
25659                                               (MATCH_w_8_24 >> 3 & 0x7) 
25660                                                     /* index at 24 */ < 8)) { 
25661                                               unsigned Eaddr = 
25662                                                 2 + addressToPC(MATCH_p);
25663                                               nextPC = 5 + MATCH_p; 
25664                                               
25665 #line 683 "frontend/machine/pentium/decoder.m"
25666                                               
25667 
25668                                                     stmts = instantiate(pc,  "SHRB.Ev.1ow", DIS_EADDR16);
25669 
25670                                               
25671 
25672                                               
25673                                               
25674                                               
25675                                             } /*opt-block*//*opt-block+*/
25676                                             else 
25677                                               goto MATCH_label_c361;  /*opt-block+*/
25678                                             
25679                                             break;
25680                                           case 2: 
25681                                             MATCH_w_8_24 = 
25682                                               getByte(3 + MATCH_p); 
25683                                             if ((MATCH_w_8_16 & 0x7) 
25684                                                     /* r_m at 16 */ == 4 && 
25685                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25686                                                     /* index at 24 */ && 
25687                                               (MATCH_w_8_24 >> 3 & 0x7) 
25688                                                     /* index at 24 */ < 8)) 
25689                                               goto MATCH_label_c362;  /*opt-block+*/
25690                                             else 
25691                                               goto MATCH_label_c363;  /*opt-block+*/
25692                                             
25693                                             break;
25694                                           case 3: 
25695                                             goto MATCH_label_c360; break;
25696                                           default: assert(0);
25697                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
25698                                               -- mod at 16 --*/ 
25699                                       break;
25700                                     case 6: 
25701                                       goto MATCH_label_c64; break;
25702                                     case 7: 
25703                                       
25704                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
25705                                               /* mod at 16 */) {
25706                                           case 0: 
25707                                             
25708                                               switch((MATCH_w_8_16 & 0x7) 
25709                                                     /* r_m at 16 */) {
25710                                                 case 0: case 1: case 2: 
25711                                                 case 3: case 6: case 7: 
25712                                                   goto MATCH_label_c364; 
25713                                                   
25714                                                   break;
25715                                                 case 4: 
25716                                                   MATCH_w_8_24 = 
25717                                                     getByte(3 + MATCH_p); 
25718                                                   if ((MATCH_w_8_24 & 0x7) 
25719                                                           /* base at 24 */ == 5 && 
25720                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25721                                                           /* index at 24 */ && 
25722                                                     (MATCH_w_8_24 >> 3 & 0x7) 
25723                                                           /* index at 24 */ < 8)) 
25724                                                     goto MATCH_label_c366;  /*opt-block+*/
25725                                                   else 
25726                                                     goto MATCH_label_c365;  /*opt-block+*/
25727                                                   
25728                                                   break;
25729                                                 case 5: 
25730                                                   goto MATCH_label_c367; 
25731                                                   
25732                                                   break;
25733                                                 default: assert(0);
25734                                               } /* (MATCH_w_8_16 & 0x7) 
25735                                                     -- r_m at 16 --*/ 
25736                                             break;
25737                                           case 1: 
25738                                             MATCH_w_8_24 = 
25739                                               getByte(3 + MATCH_p); 
25740                                             if ((MATCH_w_8_16 & 0x7) 
25741                                                     /* r_m at 16 */ == 4 && 
25742                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25743                                                     /* index at 24 */ && 
25744                                               (MATCH_w_8_24 >> 3 & 0x7) 
25745                                                     /* index at 24 */ < 8)) { 
25746                                               unsigned Eaddr = 
25747                                                 2 + addressToPC(MATCH_p);
25748                                               nextPC = 5 + MATCH_p; 
25749                                               
25750 #line 671 "frontend/machine/pentium/decoder.m"
25751                                               
25752 
25753                                                     stmts = instantiate(pc,  "SARB.Ev.1ow", DIS_EADDR16);
25754 
25755                                               
25756 
25757                                               
25758                                               
25759                                               
25760                                             } /*opt-block*//*opt-block+*/
25761                                             else 
25762                                               goto MATCH_label_c365;  /*opt-block+*/
25763                                             
25764                                             break;
25765                                           case 2: 
25766                                             MATCH_w_8_24 = 
25767                                               getByte(3 + MATCH_p); 
25768                                             if ((MATCH_w_8_16 & 0x7) 
25769                                                     /* r_m at 16 */ == 4 && 
25770                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25771                                                     /* index at 24 */ && 
25772                                               (MATCH_w_8_24 >> 3 & 0x7) 
25773                                                     /* index at 24 */ < 8)) 
25774                                               goto MATCH_label_c366;  /*opt-block+*/
25775                                             else 
25776                                               goto MATCH_label_c367;  /*opt-block+*/
25777                                             
25778                                             break;
25779                                           case 3: 
25780                                             goto MATCH_label_c364; break;
25781                                           default: assert(0);
25782                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
25783                                               -- mod at 16 --*/ 
25784                                       break;
25785                                     default: assert(0);
25786                                   } /* (MATCH_w_8_16 >> 3 & 0x7) 
25787                                         -- reg_opcode at 16 --*/ 
25788                                 
25789                               } /*opt-block*/
25790                               break;
25791                             case 3: 
25792                               if ((MATCH_w_8_8 >> 3 & 0x1) 
25793                                       /* page at 8 */ == 1) 
25794                                 goto MATCH_label_c64;  /*opt-block+*/
25795                               else { 
25796                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
25797                                 
25798                                   switch((MATCH_w_8_16 >> 3 & 0x7) 
25799                                         /* reg_opcode at 16 */) {
25800                                     case 0: 
25801                                       
25802                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
25803                                               /* mod at 16 */) {
25804                                           case 0: 
25805                                             
25806                                               switch((MATCH_w_8_16 & 0x7) 
25807                                                     /* r_m at 16 */) {
25808                                                 case 0: case 1: case 2: 
25809                                                 case 3: case 6: case 7: 
25810                                                   goto MATCH_label_c368; 
25811                                                   
25812                                                   break;
25813                                                 case 4: 
25814                                                   MATCH_w_8_24 = 
25815                                                     getByte(3 + MATCH_p); 
25816                                                   if ((MATCH_w_8_24 & 0x7) 
25817                                                           /* base at 24 */ == 5 && 
25818                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25819                                                           /* index at 24 */ && 
25820                                                     (MATCH_w_8_24 >> 3 & 0x7) 
25821                                                           /* index at 24 */ < 8)) 
25822                                                     goto MATCH_label_c370;  /*opt-block+*/
25823                                                   else 
25824                                                     goto MATCH_label_c369;  /*opt-block+*/
25825                                                   
25826                                                   break;
25827                                                 case 5: 
25828                                                   goto MATCH_label_c371; 
25829                                                   
25830                                                   break;
25831                                                 default: assert(0);
25832                                               } /* (MATCH_w_8_16 & 0x7) 
25833                                                     -- r_m at 16 --*/ 
25834                                             break;
25835                                           case 1: 
25836                                             MATCH_w_8_24 = 
25837                                               getByte(3 + MATCH_p); 
25838                                             if ((MATCH_w_8_16 & 0x7) 
25839                                                     /* r_m at 16 */ == 4 && 
25840                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25841                                                     /* index at 24 */ && 
25842                                               (MATCH_w_8_24 >> 3 & 0x7) 
25843                                                     /* index at 24 */ < 8)) { 
25844                                               unsigned Eaddr = 
25845                                                 2 + addressToPC(MATCH_p);
25846                                               nextPC = 5 + MATCH_p; 
25847                                               
25848 #line 737 "frontend/machine/pentium/decoder.m"
25849                                               
25850 
25851                                                     stmts = instantiate(pc,  "ROLB.Ev.CLow", DIS_EADDR16);
25852 
25853                                               
25854 
25855                                               
25856                                               
25857                                               
25858                                             } /*opt-block*//*opt-block+*/
25859                                             else 
25860                                               goto MATCH_label_c369;  /*opt-block+*/
25861                                             
25862                                             break;
25863                                           case 2: 
25864                                             MATCH_w_8_24 = 
25865                                               getByte(3 + MATCH_p); 
25866                                             if ((MATCH_w_8_16 & 0x7) 
25867                                                     /* r_m at 16 */ == 4 && 
25868                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25869                                                     /* index at 24 */ && 
25870                                               (MATCH_w_8_24 >> 3 & 0x7) 
25871                                                     /* index at 24 */ < 8)) 
25872                                               goto MATCH_label_c370;  /*opt-block+*/
25873                                             else 
25874                                               goto MATCH_label_c371;  /*opt-block+*/
25875                                             
25876                                             break;
25877                                           case 3: 
25878                                             goto MATCH_label_c368; break;
25879                                           default: assert(0);
25880                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
25881                                               -- mod at 16 --*/ 
25882                                       break;
25883                                     case 1: 
25884                                       
25885                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
25886                                               /* mod at 16 */) {
25887                                           case 0: 
25888                                             
25889                                               switch((MATCH_w_8_16 & 0x7) 
25890                                                     /* r_m at 16 */) {
25891                                                 case 0: case 1: case 2: 
25892                                                 case 3: case 6: case 7: 
25893                                                   goto MATCH_label_c372; 
25894                                                   
25895                                                   break;
25896                                                 case 4: 
25897                                                   MATCH_w_8_24 = 
25898                                                     getByte(3 + MATCH_p); 
25899                                                   if ((MATCH_w_8_24 & 0x7) 
25900                                                           /* base at 24 */ == 5 && 
25901                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25902                                                           /* index at 24 */ && 
25903                                                     (MATCH_w_8_24 >> 3 & 0x7) 
25904                                                           /* index at 24 */ < 8)) 
25905                                                     goto MATCH_label_c374;  /*opt-block+*/
25906                                                   else 
25907                                                     goto MATCH_label_c373;  /*opt-block+*/
25908                                                   
25909                                                   break;
25910                                                 case 5: 
25911                                                   goto MATCH_label_c375; 
25912                                                   
25913                                                   break;
25914                                                 default: assert(0);
25915                                               } /* (MATCH_w_8_16 & 0x7) 
25916                                                     -- r_m at 16 --*/ 
25917                                             break;
25918                                           case 1: 
25919                                             MATCH_w_8_24 = 
25920                                               getByte(3 + MATCH_p); 
25921                                             if ((MATCH_w_8_16 & 0x7) 
25922                                                     /* r_m at 16 */ == 4 && 
25923                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25924                                                     /* index at 24 */ && 
25925                                               (MATCH_w_8_24 >> 3 & 0x7) 
25926                                                     /* index at 24 */ < 8)) { 
25927                                               unsigned Eaddr = 
25928                                                 2 + addressToPC(MATCH_p);
25929                                               nextPC = 5 + MATCH_p; 
25930                                               
25931 #line 725 "frontend/machine/pentium/decoder.m"
25932                                               
25933 
25934                                                     stmts = instantiate(pc,  "RORB.Ev.CLow", DIS_EADDR16);
25935 
25936                                               
25937 
25938                                               
25939                                               
25940                                               
25941                                             } /*opt-block*//*opt-block+*/
25942                                             else 
25943                                               goto MATCH_label_c373;  /*opt-block+*/
25944                                             
25945                                             break;
25946                                           case 2: 
25947                                             MATCH_w_8_24 = 
25948                                               getByte(3 + MATCH_p); 
25949                                             if ((MATCH_w_8_16 & 0x7) 
25950                                                     /* r_m at 16 */ == 4 && 
25951                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25952                                                     /* index at 24 */ && 
25953                                               (MATCH_w_8_24 >> 3 & 0x7) 
25954                                                     /* index at 24 */ < 8)) 
25955                                               goto MATCH_label_c374;  /*opt-block+*/
25956                                             else 
25957                                               goto MATCH_label_c375;  /*opt-block+*/
25958                                             
25959                                             break;
25960                                           case 3: 
25961                                             goto MATCH_label_c372; break;
25962                                           default: assert(0);
25963                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
25964                                               -- mod at 16 --*/ 
25965                                       break;
25966                                     case 2: 
25967                                       
25968                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
25969                                               /* mod at 16 */) {
25970                                           case 0: 
25971                                             
25972                                               switch((MATCH_w_8_16 & 0x7) 
25973                                                     /* r_m at 16 */) {
25974                                                 case 0: case 1: case 2: 
25975                                                 case 3: case 6: case 7: 
25976                                                   goto MATCH_label_c376; 
25977                                                   
25978                                                   break;
25979                                                 case 4: 
25980                                                   MATCH_w_8_24 = 
25981                                                     getByte(3 + MATCH_p); 
25982                                                   if ((MATCH_w_8_24 & 0x7) 
25983                                                           /* base at 24 */ == 5 && 
25984                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
25985                                                           /* index at 24 */ && 
25986                                                     (MATCH_w_8_24 >> 3 & 0x7) 
25987                                                           /* index at 24 */ < 8)) 
25988                                                     goto MATCH_label_c378;  /*opt-block+*/
25989                                                   else 
25990                                                     goto MATCH_label_c377;  /*opt-block+*/
25991                                                   
25992                                                   break;
25993                                                 case 5: 
25994                                                   goto MATCH_label_c379; 
25995                                                   
25996                                                   break;
25997                                                 default: assert(0);
25998                                               } /* (MATCH_w_8_16 & 0x7) 
25999                                                     -- r_m at 16 --*/ 
26000                                             break;
26001                                           case 1: 
26002                                             MATCH_w_8_24 = 
26003                                               getByte(3 + MATCH_p); 
26004                                             if ((MATCH_w_8_16 & 0x7) 
26005                                                     /* r_m at 16 */ == 4 && 
26006                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26007                                                     /* index at 24 */ && 
26008                                               (MATCH_w_8_24 >> 3 & 0x7) 
26009                                                     /* index at 24 */ < 8)) { 
26010                                               unsigned Eaddr = 
26011                                                 2 + addressToPC(MATCH_p);
26012                                               nextPC = 5 + MATCH_p; 
26013                                               
26014 #line 713 "frontend/machine/pentium/decoder.m"
26015                                               
26016 
26017                                                     stmts = instantiate(pc,  "RCLB.Ev.CLow", DIS_EADDR16);
26018 
26019                                               
26020 
26021                                               
26022                                               
26023                                               
26024                                             } /*opt-block*//*opt-block+*/
26025                                             else 
26026                                               goto MATCH_label_c377;  /*opt-block+*/
26027                                             
26028                                             break;
26029                                           case 2: 
26030                                             MATCH_w_8_24 = 
26031                                               getByte(3 + MATCH_p); 
26032                                             if ((MATCH_w_8_16 & 0x7) 
26033                                                     /* r_m at 16 */ == 4 && 
26034                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26035                                                     /* index at 24 */ && 
26036                                               (MATCH_w_8_24 >> 3 & 0x7) 
26037                                                     /* index at 24 */ < 8)) 
26038                                               goto MATCH_label_c378;  /*opt-block+*/
26039                                             else 
26040                                               goto MATCH_label_c379;  /*opt-block+*/
26041                                             
26042                                             break;
26043                                           case 3: 
26044                                             goto MATCH_label_c376; break;
26045                                           default: assert(0);
26046                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
26047                                               -- mod at 16 --*/ 
26048                                       break;
26049                                     case 3: 
26050                                       
26051                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
26052                                               /* mod at 16 */) {
26053                                           case 0: 
26054                                             
26055                                               switch((MATCH_w_8_16 & 0x7) 
26056                                                     /* r_m at 16 */) {
26057                                                 case 0: case 1: case 2: 
26058                                                 case 3: case 6: case 7: 
26059                                                   goto MATCH_label_c380; 
26060                                                   
26061                                                   break;
26062                                                 case 4: 
26063                                                   MATCH_w_8_24 = 
26064                                                     getByte(3 + MATCH_p); 
26065                                                   if ((MATCH_w_8_24 & 0x7) 
26066                                                           /* base at 24 */ == 5 && 
26067                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26068                                                           /* index at 24 */ && 
26069                                                     (MATCH_w_8_24 >> 3 & 0x7) 
26070                                                           /* index at 24 */ < 8)) 
26071                                                     goto MATCH_label_c382;  /*opt-block+*/
26072                                                   else 
26073                                                     goto MATCH_label_c381;  /*opt-block+*/
26074                                                   
26075                                                   break;
26076                                                 case 5: 
26077                                                   goto MATCH_label_c383; 
26078                                                   
26079                                                   break;
26080                                                 default: assert(0);
26081                                               } /* (MATCH_w_8_16 & 0x7) 
26082                                                     -- r_m at 16 --*/ 
26083                                             break;
26084                                           case 1: 
26085                                             MATCH_w_8_24 = 
26086                                               getByte(3 + MATCH_p); 
26087                                             if ((MATCH_w_8_16 & 0x7) 
26088                                                     /* r_m at 16 */ == 4 && 
26089                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26090                                                     /* index at 24 */ && 
26091                                               (MATCH_w_8_24 >> 3 & 0x7) 
26092                                                     /* index at 24 */ < 8)) { 
26093                                               unsigned Eaddr = 
26094                                                 2 + addressToPC(MATCH_p);
26095                                               nextPC = 5 + MATCH_p; 
26096                                               
26097 #line 701 "frontend/machine/pentium/decoder.m"
26098                                               
26099 
26100                                                     stmts = instantiate(pc,  "RCRB.Ev.CLow", DIS_EADDR16);
26101 
26102                                               
26103 
26104                                               
26105                                               
26106                                               
26107                                             } /*opt-block*//*opt-block+*/
26108                                             else 
26109                                               goto MATCH_label_c381;  /*opt-block+*/
26110                                             
26111                                             break;
26112                                           case 2: 
26113                                             MATCH_w_8_24 = 
26114                                               getByte(3 + MATCH_p); 
26115                                             if ((MATCH_w_8_16 & 0x7) 
26116                                                     /* r_m at 16 */ == 4 && 
26117                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26118                                                     /* index at 24 */ && 
26119                                               (MATCH_w_8_24 >> 3 & 0x7) 
26120                                                     /* index at 24 */ < 8)) 
26121                                               goto MATCH_label_c382;  /*opt-block+*/
26122                                             else 
26123                                               goto MATCH_label_c383;  /*opt-block+*/
26124                                             
26125                                             break;
26126                                           case 3: 
26127                                             goto MATCH_label_c380; break;
26128                                           default: assert(0);
26129                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
26130                                               -- mod at 16 --*/ 
26131                                       break;
26132                                     case 4: 
26133                                       
26134                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
26135                                               /* mod at 16 */) {
26136                                           case 0: 
26137                                             
26138                                               switch((MATCH_w_8_16 & 0x7) 
26139                                                     /* r_m at 16 */) {
26140                                                 case 0: case 1: case 2: 
26141                                                 case 3: case 6: case 7: 
26142                                                   goto MATCH_label_c384; 
26143                                                   
26144                                                   break;
26145                                                 case 4: 
26146                                                   MATCH_w_8_24 = 
26147                                                     getByte(3 + MATCH_p); 
26148                                                   if ((MATCH_w_8_24 & 0x7) 
26149                                                           /* base at 24 */ == 5 && 
26150                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26151                                                           /* index at 24 */ && 
26152                                                     (MATCH_w_8_24 >> 3 & 0x7) 
26153                                                           /* index at 24 */ < 8)) 
26154                                                     goto MATCH_label_c386;  /*opt-block+*/
26155                                                   else 
26156                                                     goto MATCH_label_c385;  /*opt-block+*/
26157                                                   
26158                                                   break;
26159                                                 case 5: 
26160                                                   goto MATCH_label_c387; 
26161                                                   
26162                                                   break;
26163                                                 default: assert(0);
26164                                               } /* (MATCH_w_8_16 & 0x7) 
26165                                                     -- r_m at 16 --*/ 
26166                                             break;
26167                                           case 1: 
26168                                             MATCH_w_8_24 = 
26169                                               getByte(3 + MATCH_p); 
26170                                             if ((MATCH_w_8_16 & 0x7) 
26171                                                     /* r_m at 16 */ == 4 && 
26172                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26173                                                     /* index at 24 */ && 
26174                                               (MATCH_w_8_24 >> 3 & 0x7) 
26175                                                     /* index at 24 */ < 8)) { 
26176                                               unsigned Eaddr = 
26177                                                 2 + addressToPC(MATCH_p);
26178                                               nextPC = 5 + MATCH_p; 
26179                                               
26180 #line 689 "frontend/machine/pentium/decoder.m"
26181                                               
26182 
26183                                                     stmts = instantiate(pc,  "SHLSALB.Ev.CLow", DIS_EADDR16);
26184 
26185                                               
26186 
26187                                               
26188                                               
26189                                               
26190                                             } /*opt-block*//*opt-block+*/
26191                                             else 
26192                                               goto MATCH_label_c385;  /*opt-block+*/
26193                                             
26194                                             break;
26195                                           case 2: 
26196                                             MATCH_w_8_24 = 
26197                                               getByte(3 + MATCH_p); 
26198                                             if ((MATCH_w_8_16 & 0x7) 
26199                                                     /* r_m at 16 */ == 4 && 
26200                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26201                                                     /* index at 24 */ && 
26202                                               (MATCH_w_8_24 >> 3 & 0x7) 
26203                                                     /* index at 24 */ < 8)) 
26204                                               goto MATCH_label_c386;  /*opt-block+*/
26205                                             else 
26206                                               goto MATCH_label_c387;  /*opt-block+*/
26207                                             
26208                                             break;
26209                                           case 3: 
26210                                             goto MATCH_label_c384; break;
26211                                           default: assert(0);
26212                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
26213                                               -- mod at 16 --*/ 
26214                                       break;
26215                                     case 5: 
26216                                       
26217                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
26218                                               /* mod at 16 */) {
26219                                           case 0: 
26220                                             
26221                                               switch((MATCH_w_8_16 & 0x7) 
26222                                                     /* r_m at 16 */) {
26223                                                 case 0: case 1: case 2: 
26224                                                 case 3: case 6: case 7: 
26225                                                   goto MATCH_label_c388; 
26226                                                   
26227                                                   break;
26228                                                 case 4: 
26229                                                   MATCH_w_8_24 = 
26230                                                     getByte(3 + MATCH_p); 
26231                                                   if ((MATCH_w_8_24 & 0x7) 
26232                                                           /* base at 24 */ == 5 && 
26233                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26234                                                           /* index at 24 */ && 
26235                                                     (MATCH_w_8_24 >> 3 & 0x7) 
26236                                                           /* index at 24 */ < 8)) 
26237                                                     goto MATCH_label_c390;  /*opt-block+*/
26238                                                   else 
26239                                                     goto MATCH_label_c389;  /*opt-block+*/
26240                                                   
26241                                                   break;
26242                                                 case 5: 
26243                                                   goto MATCH_label_c391; 
26244                                                   
26245                                                   break;
26246                                                 default: assert(0);
26247                                               } /* (MATCH_w_8_16 & 0x7) 
26248                                                     -- r_m at 16 --*/ 
26249                                             break;
26250                                           case 1: 
26251                                             MATCH_w_8_24 = 
26252                                               getByte(3 + MATCH_p); 
26253                                             if ((MATCH_w_8_16 & 0x7) 
26254                                                     /* r_m at 16 */ == 4 && 
26255                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26256                                                     /* index at 24 */ && 
26257                                               (MATCH_w_8_24 >> 3 & 0x7) 
26258                                                     /* index at 24 */ < 8)) { 
26259                                               unsigned Eaddr = 
26260                                                 2 + addressToPC(MATCH_p);
26261                                               nextPC = 5 + MATCH_p; 
26262                                               
26263 #line 677 "frontend/machine/pentium/decoder.m"
26264                                               
26265 
26266                                                     stmts = instantiate(pc,  "SHRB.Ev.CLow", DIS_EADDR16);
26267 
26268                                               
26269 
26270                                               
26271                                               
26272                                               
26273                                             } /*opt-block*//*opt-block+*/
26274                                             else 
26275                                               goto MATCH_label_c389;  /*opt-block+*/
26276                                             
26277                                             break;
26278                                           case 2: 
26279                                             MATCH_w_8_24 = 
26280                                               getByte(3 + MATCH_p); 
26281                                             if ((MATCH_w_8_16 & 0x7) 
26282                                                     /* r_m at 16 */ == 4 && 
26283                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26284                                                     /* index at 24 */ && 
26285                                               (MATCH_w_8_24 >> 3 & 0x7) 
26286                                                     /* index at 24 */ < 8)) 
26287                                               goto MATCH_label_c390;  /*opt-block+*/
26288                                             else 
26289                                               goto MATCH_label_c391;  /*opt-block+*/
26290                                             
26291                                             break;
26292                                           case 3: 
26293                                             goto MATCH_label_c388; break;
26294                                           default: assert(0);
26295                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
26296                                               -- mod at 16 --*/ 
26297                                       break;
26298                                     case 6: 
26299                                       goto MATCH_label_c64; break;
26300                                     case 7: 
26301                                       
26302                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
26303                                               /* mod at 16 */) {
26304                                           case 0: 
26305                                             
26306                                               switch((MATCH_w_8_16 & 0x7) 
26307                                                     /* r_m at 16 */) {
26308                                                 case 0: case 1: case 2: 
26309                                                 case 3: case 6: case 7: 
26310                                                   goto MATCH_label_c392; 
26311                                                   
26312                                                   break;
26313                                                 case 4: 
26314                                                   MATCH_w_8_24 = 
26315                                                     getByte(3 + MATCH_p); 
26316                                                   if ((MATCH_w_8_24 & 0x7) 
26317                                                           /* base at 24 */ == 5 && 
26318                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26319                                                           /* index at 24 */ && 
26320                                                     (MATCH_w_8_24 >> 3 & 0x7) 
26321                                                           /* index at 24 */ < 8)) 
26322                                                     goto MATCH_label_c394;  /*opt-block+*/
26323                                                   else 
26324                                                     goto MATCH_label_c393;  /*opt-block+*/
26325                                                   
26326                                                   break;
26327                                                 case 5: 
26328                                                   goto MATCH_label_c395; 
26329                                                   
26330                                                   break;
26331                                                 default: assert(0);
26332                                               } /* (MATCH_w_8_16 & 0x7) 
26333                                                     -- r_m at 16 --*/ 
26334                                             break;
26335                                           case 1: 
26336                                             MATCH_w_8_24 = 
26337                                               getByte(3 + MATCH_p); 
26338                                             if ((MATCH_w_8_16 & 0x7) 
26339                                                     /* r_m at 16 */ == 4 && 
26340                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26341                                                     /* index at 24 */ && 
26342                                               (MATCH_w_8_24 >> 3 & 0x7) 
26343                                                     /* index at 24 */ < 8)) { 
26344                                               unsigned Eaddr = 
26345                                                 2 + addressToPC(MATCH_p);
26346                                               nextPC = 5 + MATCH_p; 
26347                                               
26348 #line 665 "frontend/machine/pentium/decoder.m"
26349                                               
26350 
26351                                                     stmts = instantiate(pc,  "SARB.Ev.CLow", DIS_EADDR16);
26352 
26353                                               
26354 
26355                                               
26356                                               
26357                                               
26358                                             } /*opt-block*//*opt-block+*/
26359                                             else 
26360                                               goto MATCH_label_c393;  /*opt-block+*/
26361                                             
26362                                             break;
26363                                           case 2: 
26364                                             MATCH_w_8_24 = 
26365                                               getByte(3 + MATCH_p); 
26366                                             if ((MATCH_w_8_16 & 0x7) 
26367                                                     /* r_m at 16 */ == 4 && 
26368                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26369                                                     /* index at 24 */ && 
26370                                               (MATCH_w_8_24 >> 3 & 0x7) 
26371                                                     /* index at 24 */ < 8)) 
26372                                               goto MATCH_label_c394;  /*opt-block+*/
26373                                             else 
26374                                               goto MATCH_label_c395;  /*opt-block+*/
26375                                             
26376                                             break;
26377                                           case 3: 
26378                                             goto MATCH_label_c392; break;
26379                                           default: assert(0);
26380                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
26381                                               -- mod at 16 --*/ 
26382                                       break;
26383                                     default: assert(0);
26384                                   } /* (MATCH_w_8_16 >> 3 & 0x7) 
26385                                         -- reg_opcode at 16 --*/ 
26386                                 
26387                               } /*opt-block*/
26388                               break;
26389                             default: assert(0);
26390                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
26391                         break;
26392                       case 14: 
26393                         if ((MATCH_w_8_8 & 0x7) /* col at 8 */ == 1 && 
26394                           (MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) { 
26395                           MATCH_w_16_16 = getWord(2 + MATCH_p); 
26396                           MATCH_name = 
26397                             MATCH_name_page_0[(MATCH_w_8_8 >> 3 & 0x1) 
26398                                 /* page at 8 */]; 
26399                           { 
26400                             char *name = MATCH_name;
26401                             unsigned relocd = 
26402                               4 + sign_extend((MATCH_w_16_16 & 0xffff) 
26403                                                 /* i16 at 16 */, 16) + 
26404                               addressToPC(MATCH_p);
26405                             nextPC = 4 + MATCH_p; 
26406                             
26407 #line 151 "frontend/machine/pentium/decoder.m"
26408                             
26409 
26410                                     unused((int) name);
26411 
26412                                     unconditionalJump(name, 3, relocd, delta, pc, stmts, result);
26413 
26414                             
26415                             
26416                             
26417                           }
26418                           
26419                         } /*opt-block*/
26420                         else 
26421                           goto MATCH_label_c64;  /*opt-block+*/
26422                         
26423                         break;
26424                       case 15: 
26425                         if ((MATCH_w_8_8 & 0x7) /* col at 8 */ == 7) 
26426                           if ((MATCH_w_8_8 >> 3 & 0x1) 
26427                                   /* page at 8 */ == 1) { 
26428                             MATCH_w_8_16 = getByte(2 + MATCH_p); 
26429                             
26430                               switch((MATCH_w_8_16 >> 3 & 0x7) 
26431                                     /* reg_opcode at 16 */) {
26432                                 case 0: 
26433                                   
26434                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
26435                                           /* mod at 16 */) {
26436                                       case 0: 
26437                                         
26438                                           switch((MATCH_w_8_16 & 0x7) 
26439                                                 /* r_m at 16 */) {
26440                                             case 0: case 1: case 2: case 3: 
26441                                             case 6: case 7: 
26442                                               goto MATCH_label_c424; break;
26443                                             case 4: 
26444                                               MATCH_w_8_24 = 
26445                                                 getByte(3 + MATCH_p); 
26446                                               if ((MATCH_w_8_24 & 0x7) 
26447                                                       /* base at 24 */ == 5 && 
26448                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26449                                                       /* index at 24 */ && 
26450                                                 (MATCH_w_8_24 >> 3 & 0x7) 
26451                                                       /* index at 24 */ < 8)) 
26452                                                 goto MATCH_label_c426;  /*opt-block+*/
26453                                               else 
26454                                                 goto MATCH_label_c425;  /*opt-block+*/
26455                                               
26456                                               break;
26457                                             case 5: 
26458                                               goto MATCH_label_c427; break;
26459                                             default: assert(0);
26460                                           } /* (MATCH_w_8_16 & 0x7) 
26461                                                 -- r_m at 16 --*/ 
26462                                         break;
26463                                       case 1: 
26464                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
26465                                         if ((MATCH_w_8_16 & 0x7) 
26466                                                 /* r_m at 16 */ == 4 && 
26467                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26468                                                 /* index at 24 */ && 
26469                                           (MATCH_w_8_24 >> 3 & 0x7) 
26470                                                 /* index at 24 */ < 8)) { 
26471                                           unsigned Eaddr = 
26472                                             2 + addressToPC(MATCH_p);
26473                                           nextPC = 5 + MATCH_p; 
26474                                           
26475 #line 1130 "frontend/machine/pentium/decoder.m"
26476                                           
26477 
26478                                                 stmts = instantiate(pc,  "INC.Evow", DIS_EADDR16);
26479 
26480                                           
26481 
26482                                           
26483                                           
26484                                           
26485                                         } /*opt-block*//*opt-block+*/
26486                                         else 
26487                                           goto MATCH_label_c425;  /*opt-block+*/
26488                                         
26489                                         break;
26490                                       case 2: 
26491                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
26492                                         if ((MATCH_w_8_16 & 0x7) 
26493                                                 /* r_m at 16 */ == 4 && 
26494                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26495                                                 /* index at 24 */ && 
26496                                           (MATCH_w_8_24 >> 3 & 0x7) 
26497                                                 /* index at 24 */ < 8)) 
26498                                           goto MATCH_label_c426;  /*opt-block+*/
26499                                         else 
26500                                           goto MATCH_label_c427;  /*opt-block+*/
26501                                         
26502                                         break;
26503                                       case 3: 
26504                                         goto MATCH_label_c424; break;
26505                                       default: assert(0);
26506                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
26507                                           -- mod at 16 --*/ 
26508                                   break;
26509                                 case 1: 
26510                                   
26511                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
26512                                           /* mod at 16 */) {
26513                                       case 0: 
26514                                         
26515                                           switch((MATCH_w_8_16 & 0x7) 
26516                                                 /* r_m at 16 */) {
26517                                             case 0: case 1: case 2: case 3: 
26518                                             case 6: case 7: 
26519                                               goto MATCH_label_c428; break;
26520                                             case 4: 
26521                                               MATCH_w_8_24 = 
26522                                                 getByte(3 + MATCH_p); 
26523                                               if ((MATCH_w_8_24 & 0x7) 
26524                                                       /* base at 24 */ == 5 && 
26525                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26526                                                       /* index at 24 */ && 
26527                                                 (MATCH_w_8_24 >> 3 & 0x7) 
26528                                                       /* index at 24 */ < 8)) 
26529                                                 goto MATCH_label_c430;  /*opt-block+*/
26530                                               else 
26531                                                 goto MATCH_label_c429;  /*opt-block+*/
26532                                               
26533                                               break;
26534                                             case 5: 
26535                                               goto MATCH_label_c431; break;
26536                                             default: assert(0);
26537                                           } /* (MATCH_w_8_16 & 0x7) 
26538                                                 -- r_m at 16 --*/ 
26539                                         break;
26540                                       case 1: 
26541                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
26542                                         if ((MATCH_w_8_16 & 0x7) 
26543                                                 /* r_m at 16 */ == 4 && 
26544                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26545                                                 /* index at 24 */ && 
26546                                           (MATCH_w_8_24 >> 3 & 0x7) 
26547                                                 /* index at 24 */ < 8)) { 
26548                                           unsigned Eaddr = 
26549                                             2 + addressToPC(MATCH_p);
26550                                           nextPC = 5 + MATCH_p; 
26551                                           
26552 #line 1214 "frontend/machine/pentium/decoder.m"
26553                                           
26554 
26555                                                 stmts = instantiate(pc,  "DEC.Evow", DIS_EADDR16);
26556 
26557                                           
26558 
26559                                           
26560                                           
26561                                           
26562                                         } /*opt-block*//*opt-block+*/
26563                                         else 
26564                                           goto MATCH_label_c429;  /*opt-block+*/
26565                                         
26566                                         break;
26567                                       case 2: 
26568                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
26569                                         if ((MATCH_w_8_16 & 0x7) 
26570                                                 /* r_m at 16 */ == 4 && 
26571                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26572                                                 /* index at 24 */ && 
26573                                           (MATCH_w_8_24 >> 3 & 0x7) 
26574                                                 /* index at 24 */ < 8)) 
26575                                           goto MATCH_label_c430;  /*opt-block+*/
26576                                         else 
26577                                           goto MATCH_label_c431;  /*opt-block+*/
26578                                         
26579                                         break;
26580                                       case 3: 
26581                                         goto MATCH_label_c428; break;
26582                                       default: assert(0);
26583                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
26584                                           -- mod at 16 --*/ 
26585                                   break;
26586                                 case 2: case 3: case 4: case 5: case 7: 
26587                                   goto MATCH_label_c64; break;
26588                                 case 6: 
26589                                   
26590                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
26591                                           /* mod at 16 */) {
26592                                       case 0: 
26593                                         
26594                                           switch((MATCH_w_8_16 & 0x7) 
26595                                                 /* r_m at 16 */) {
26596                                             case 0: case 1: case 2: case 3: 
26597                                             case 6: case 7: 
26598                                               goto MATCH_label_c432; break;
26599                                             case 4: 
26600                                               MATCH_w_8_24 = 
26601                                                 getByte(3 + MATCH_p); 
26602                                               if ((MATCH_w_8_24 & 0x7) 
26603                                                       /* base at 24 */ == 5 && 
26604                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26605                                                       /* index at 24 */ && 
26606                                                 (MATCH_w_8_24 >> 3 & 0x7) 
26607                                                       /* index at 24 */ < 8)) 
26608                                                 goto MATCH_label_c434;  /*opt-block+*/
26609                                               else 
26610                                                 goto MATCH_label_c433;  /*opt-block+*/
26611                                               
26612                                               break;
26613                                             case 5: 
26614                                               goto MATCH_label_c435; break;
26615                                             default: assert(0);
26616                                           } /* (MATCH_w_8_16 & 0x7) 
26617                                                 -- r_m at 16 --*/ 
26618                                         break;
26619                                       case 1: 
26620                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
26621                                         if ((MATCH_w_8_16 & 0x7) 
26622                                                 /* r_m at 16 */ == 4 && 
26623                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26624                                                 /* index at 24 */ && 
26625                                           (MATCH_w_8_24 >> 3 & 0x7) 
26626                                                 /* index at 24 */ < 8)) { 
26627                                           unsigned Eaddr = 
26628                                             2 + addressToPC(MATCH_p);
26629                                           nextPC = 5 + MATCH_p; 
26630                                           
26631 #line 841 "frontend/machine/pentium/decoder.m"
26632                                           
26633 
26634                                                 stmts = instantiate(pc,  "PUSH.Evow", DIS_EADDR16);
26635 
26636                                           
26637 
26638                                           //      | POPFod() =>
26639 
26640                                           //          stmts = instantiate(pc,  "POPFod");
26641 
26642                                           
26643 
26644                                           //      | POPFow() =>
26645 
26646                                           //          stmts = instantiate(pc,  "POPFow");
26647 
26648                                           
26649 
26650                                           //      | POPAod() =>
26651 
26652                                           //          stmts = instantiate(pc,  "POPAod");
26653 
26654                                           
26655 
26656                                           //      | POPAow() =>
26657 
26658                                           //          stmts = instantiate(pc,  "POPAow");
26659 
26660                                           
26661 
26662                                           
26663                                           
26664                                           
26665                                         } /*opt-block*//*opt-block+*/
26666                                         else 
26667                                           goto MATCH_label_c433;  /*opt-block+*/
26668                                         
26669                                         break;
26670                                       case 2: 
26671                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
26672                                         if ((MATCH_w_8_16 & 0x7) 
26673                                                 /* r_m at 16 */ == 4 && 
26674                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26675                                                 /* index at 24 */ && 
26676                                           (MATCH_w_8_24 >> 3 & 0x7) 
26677                                                 /* index at 24 */ < 8)) 
26678                                           goto MATCH_label_c434;  /*opt-block+*/
26679                                         else 
26680                                           goto MATCH_label_c435;  /*opt-block+*/
26681                                         
26682                                         break;
26683                                       case 3: 
26684                                         goto MATCH_label_c432; break;
26685                                       default: assert(0);
26686                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
26687                                           -- mod at 16 --*/ 
26688                                   break;
26689                                 default: assert(0);
26690                               } /* (MATCH_w_8_16 >> 3 & 0x7) 
26691                                     -- reg_opcode at 16 --*/ 
26692                             
26693                           } /*opt-block*/
26694                           else { 
26695                             MATCH_w_8_16 = getByte(2 + MATCH_p); 
26696                             
26697                               switch((MATCH_w_8_16 >> 3 & 0x7) 
26698                                     /* reg_opcode at 16 */) {
26699                                 case 0: 
26700                                   
26701                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
26702                                           /* mod at 16 */) {
26703                                       case 0: 
26704                                         
26705                                           switch((MATCH_w_8_16 & 0x7) 
26706                                                 /* r_m at 16 */) {
26707                                             case 0: case 1: case 2: case 3: 
26708                                             case 6: case 7: 
26709                                               MATCH_w_16_24 = 
26710                                                 getWord(3 + MATCH_p); 
26711                                               goto MATCH_label_c396; 
26712                                               
26713                                               break;
26714                                             case 4: 
26715                                               MATCH_w_8_24 = 
26716                                                 getByte(3 + MATCH_p); 
26717                                               if ((MATCH_w_8_24 & 0x7) 
26718                                                       /* base at 24 */ == 5 && 
26719                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26720                                                       /* index at 24 */ && 
26721                                                 (MATCH_w_8_24 >> 3 & 0x7) 
26722                                                       /* index at 24 */ < 8)) { 
26723                                                 MATCH_w_16_64 = 
26724                                                   getWord(8 + MATCH_p); 
26725                                                 goto MATCH_label_c398; 
26726                                                 
26727                                               } /*opt-block*/
26728                                               else { 
26729                                                 MATCH_w_16_32 = 
26730                                                   getWord(4 + MATCH_p); 
26731                                                 goto MATCH_label_c397; 
26732                                                 
26733                                               } /*opt-block*/
26734                                               
26735                                               break;
26736                                             case 5: 
26737                                               MATCH_w_16_56 = 
26738                                                 getWord(7 + MATCH_p); 
26739                                               goto MATCH_label_c399; 
26740                                               
26741                                               break;
26742                                             default: assert(0);
26743                                           } /* (MATCH_w_8_16 & 0x7) 
26744                                                 -- r_m at 16 --*/ 
26745                                         break;
26746                                       case 1: 
26747                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
26748                                         if ((MATCH_w_8_16 & 0x7) 
26749                                                 /* r_m at 16 */ == 4 && 
26750                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26751                                                 /* index at 24 */ && 
26752                                           (MATCH_w_8_24 >> 3 & 0x7) 
26753                                                 /* index at 24 */ < 8)) { 
26754                                           MATCH_w_16_40 = 
26755                                             getWord(5 + MATCH_p); 
26756                                           { 
26757                                             unsigned Eaddr = 
26758                                               2 + addressToPC(MATCH_p);
26759                                             unsigned i16 = 
26760                                               (MATCH_w_16_40 & 0xffff) 
26761                                                     /* i16 at 40 */;
26762                                             nextPC = 7 + MATCH_p; 
26763                                             
26764 #line 390 "frontend/machine/pentium/decoder.m"
26765                                             
26766 
26767                                                     stmts = instantiate(pc,  "TEST.Ew.Iw", DIS_EADDR16, DIS_I16);
26768 
26769                                             
26770 
26771                                             
26772                                             
26773                                             
26774                                           }
26775                                           
26776                                         } /*opt-block*/
26777                                         else { 
26778                                           MATCH_w_16_32 = 
26779                                             getWord(4 + MATCH_p); 
26780                                           goto MATCH_label_c397; 
26781                                           
26782                                         } /*opt-block*/
26783                                         
26784                                         break;
26785                                       case 2: 
26786                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
26787                                         if ((MATCH_w_8_16 & 0x7) 
26788                                                 /* r_m at 16 */ == 4 && 
26789                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26790                                                 /* index at 24 */ && 
26791                                           (MATCH_w_8_24 >> 3 & 0x7) 
26792                                                 /* index at 24 */ < 8)) { 
26793                                           MATCH_w_16_64 = 
26794                                             getWord(8 + MATCH_p); 
26795                                           goto MATCH_label_c398; 
26796                                           
26797                                         } /*opt-block*/
26798                                         else { 
26799                                           MATCH_w_16_56 = 
26800                                             getWord(7 + MATCH_p); 
26801                                           goto MATCH_label_c399; 
26802                                           
26803                                         } /*opt-block*/
26804                                         
26805                                         break;
26806                                       case 3: 
26807                                         MATCH_w_16_24 = getWord(3 + MATCH_p); 
26808                                         goto MATCH_label_c396; 
26809                                         
26810                                         break;
26811                                       default: assert(0);
26812                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
26813                                           -- mod at 16 --*/ 
26814                                   break;
26815                                 case 1: 
26816                                   goto MATCH_label_c64; break;
26817                                 case 2: 
26818                                   
26819                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
26820                                           /* mod at 16 */) {
26821                                       case 0: 
26822                                         
26823                                           switch((MATCH_w_8_16 & 0x7) 
26824                                                 /* r_m at 16 */) {
26825                                             case 0: case 1: case 2: case 3: 
26826                                             case 6: case 7: 
26827                                               goto MATCH_label_c400; break;
26828                                             case 4: 
26829                                               MATCH_w_8_24 = 
26830                                                 getByte(3 + MATCH_p); 
26831                                               if ((MATCH_w_8_24 & 0x7) 
26832                                                       /* base at 24 */ == 5 && 
26833                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26834                                                       /* index at 24 */ && 
26835                                                 (MATCH_w_8_24 >> 3 & 0x7) 
26836                                                       /* index at 24 */ < 8)) 
26837                                                 goto MATCH_label_c402;  /*opt-block+*/
26838                                               else 
26839                                                 goto MATCH_label_c401;  /*opt-block+*/
26840                                               
26841                                               break;
26842                                             case 5: 
26843                                               goto MATCH_label_c403; break;
26844                                             default: assert(0);
26845                                           } /* (MATCH_w_8_16 & 0x7) 
26846                                                 -- r_m at 16 --*/ 
26847                                         break;
26848                                       case 1: 
26849                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
26850                                         if ((MATCH_w_8_16 & 0x7) 
26851                                                 /* r_m at 16 */ == 4 && 
26852                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26853                                                 /* index at 24 */ && 
26854                                           (MATCH_w_8_24 >> 3 & 0x7) 
26855                                                 /* index at 24 */ < 8)) { 
26856                                           unsigned Eaddr = 
26857                                             2 + addressToPC(MATCH_p);
26858                                           nextPC = 5 + MATCH_p; 
26859                                           
26860 #line 913 "frontend/machine/pentium/decoder.m"
26861                                           
26862 
26863                                                 stmts = instantiate(pc,  "NOTow", DIS_EADDR16);
26864 
26865                                           
26866 
26867                                           
26868                                           
26869                                           
26870                                         } /*opt-block*//*opt-block+*/
26871                                         else 
26872                                           goto MATCH_label_c401;  /*opt-block+*/
26873                                         
26874                                         break;
26875                                       case 2: 
26876                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
26877                                         if ((MATCH_w_8_16 & 0x7) 
26878                                                 /* r_m at 16 */ == 4 && 
26879                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26880                                                 /* index at 24 */ && 
26881                                           (MATCH_w_8_24 >> 3 & 0x7) 
26882                                                 /* index at 24 */ < 8)) 
26883                                           goto MATCH_label_c402;  /*opt-block+*/
26884                                         else 
26885                                           goto MATCH_label_c403;  /*opt-block+*/
26886                                         
26887                                         break;
26888                                       case 3: 
26889                                         goto MATCH_label_c400; break;
26890                                       default: assert(0);
26891                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
26892                                           -- mod at 16 --*/ 
26893                                   break;
26894                                 case 3: 
26895                                   
26896                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
26897                                           /* mod at 16 */) {
26898                                       case 0: 
26899                                         
26900                                           switch((MATCH_w_8_16 & 0x7) 
26901                                                 /* r_m at 16 */) {
26902                                             case 0: case 1: case 2: case 3: 
26903                                             case 6: case 7: 
26904                                               goto MATCH_label_c404; break;
26905                                             case 4: 
26906                                               MATCH_w_8_24 = 
26907                                                 getByte(3 + MATCH_p); 
26908                                               if ((MATCH_w_8_24 & 0x7) 
26909                                                       /* base at 24 */ == 5 && 
26910                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26911                                                       /* index at 24 */ && 
26912                                                 (MATCH_w_8_24 >> 3 & 0x7) 
26913                                                       /* index at 24 */ < 8)) 
26914                                                 goto MATCH_label_c406;  /*opt-block+*/
26915                                               else 
26916                                                 goto MATCH_label_c405;  /*opt-block+*/
26917                                               
26918                                               break;
26919                                             case 5: 
26920                                               goto MATCH_label_c407; break;
26921                                             default: assert(0);
26922                                           } /* (MATCH_w_8_16 & 0x7) 
26923                                                 -- r_m at 16 --*/ 
26924                                         break;
26925                                       case 1: 
26926                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
26927                                         if ((MATCH_w_8_16 & 0x7) 
26928                                                 /* r_m at 16 */ == 4 && 
26929                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26930                                                 /* index at 24 */ && 
26931                                           (MATCH_w_8_24 >> 3 & 0x7) 
26932                                                 /* index at 24 */ < 8)) { 
26933                                           unsigned Eaddr = 
26934                                             2 + addressToPC(MATCH_p);
26935                                           nextPC = 5 + MATCH_p; 
26936                                           
26937 #line 922 "frontend/machine/pentium/decoder.m"
26938                                           
26939 
26940                                                 stmts = instantiate(pc,  "NEGow", DIS_EADDR16);
26941 
26942                                           
26943 
26944                                           
26945                                           
26946                                           
26947                                         } /*opt-block*//*opt-block+*/
26948                                         else 
26949                                           goto MATCH_label_c405;  /*opt-block+*/
26950                                         
26951                                         break;
26952                                       case 2: 
26953                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
26954                                         if ((MATCH_w_8_16 & 0x7) 
26955                                                 /* r_m at 16 */ == 4 && 
26956                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26957                                                 /* index at 24 */ && 
26958                                           (MATCH_w_8_24 >> 3 & 0x7) 
26959                                                 /* index at 24 */ < 8)) 
26960                                           goto MATCH_label_c406;  /*opt-block+*/
26961                                         else 
26962                                           goto MATCH_label_c407;  /*opt-block+*/
26963                                         
26964                                         break;
26965                                       case 3: 
26966                                         goto MATCH_label_c404; break;
26967                                       default: assert(0);
26968                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
26969                                           -- mod at 16 --*/ 
26970                                   break;
26971                                 case 4: 
26972                                   
26973                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
26974                                           /* mod at 16 */) {
26975                                       case 0: 
26976                                         
26977                                           switch((MATCH_w_8_16 & 0x7) 
26978                                                 /* r_m at 16 */) {
26979                                             case 0: case 1: case 2: case 3: 
26980                                             case 6: case 7: 
26981                                               goto MATCH_label_c408; break;
26982                                             case 4: 
26983                                               MATCH_w_8_24 = 
26984                                                 getByte(3 + MATCH_p); 
26985                                               if ((MATCH_w_8_24 & 0x7) 
26986                                                       /* base at 24 */ == 5 && 
26987                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
26988                                                       /* index at 24 */ && 
26989                                                 (MATCH_w_8_24 >> 3 & 0x7) 
26990                                                       /* index at 24 */ < 8)) 
26991                                                 goto MATCH_label_c410;  /*opt-block+*/
26992                                               else 
26993                                                 goto MATCH_label_c409;  /*opt-block+*/
26994                                               
26995                                               break;
26996                                             case 5: 
26997                                               goto MATCH_label_c411; break;
26998                                             default: assert(0);
26999                                           } /* (MATCH_w_8_16 & 0x7) 
27000                                                 -- r_m at 16 --*/ 
27001                                         break;
27002                                       case 1: 
27003                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
27004                                         if ((MATCH_w_8_16 & 0x7) 
27005                                                 /* r_m at 16 */ == 4 && 
27006                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
27007                                                 /* index at 24 */ && 
27008                                           (MATCH_w_8_24 >> 3 & 0x7) 
27009                                                 /* index at 24 */ < 8)) { 
27010                                           unsigned Eaddr = 
27011                                             2 + addressToPC(MATCH_p);
27012                                           nextPC = 5 + MATCH_p; 
27013                                           
27014 #line 931 "frontend/machine/pentium/decoder.m"
27015                                           
27016 
27017                                                 stmts = instantiate(pc,  "MUL.AXow", DIS_EADDR16);
27018 
27019                                           
27020 
27021                                           
27022                                           
27023                                           
27024                                         } /*opt-block*//*opt-block+*/
27025                                         else 
27026                                           goto MATCH_label_c409;  /*opt-block+*/
27027                                         
27028                                         break;
27029                                       case 2: 
27030                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
27031                                         if ((MATCH_w_8_16 & 0x7) 
27032                                                 /* r_m at 16 */ == 4 && 
27033                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
27034                                                 /* index at 24 */ && 
27035                                           (MATCH_w_8_24 >> 3 & 0x7) 
27036                                                 /* index at 24 */ < 8)) 
27037                                           goto MATCH_label_c410;  /*opt-block+*/
27038                                         else 
27039                                           goto MATCH_label_c411;  /*opt-block+*/
27040                                         
27041                                         break;
27042                                       case 3: 
27043                                         goto MATCH_label_c408; break;
27044                                       default: assert(0);
27045                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
27046                                           -- mod at 16 --*/ 
27047                                   break;
27048                                 case 5: 
27049                                   
27050                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
27051                                           /* mod at 16 */) {
27052                                       case 0: 
27053                                         
27054                                           switch((MATCH_w_8_16 & 0x7) 
27055                                                 /* r_m at 16 */) {
27056                                             case 0: case 1: case 2: case 3: 
27057                                             case 6: case 7: 
27058                                               goto MATCH_label_c412; break;
27059                                             case 4: 
27060                                               MATCH_w_8_24 = 
27061                                                 getByte(3 + MATCH_p); 
27062                                               if ((MATCH_w_8_24 & 0x7) 
27063                                                       /* base at 24 */ == 5 && 
27064                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
27065                                                       /* index at 24 */ && 
27066                                                 (MATCH_w_8_24 >> 3 & 0x7) 
27067                                                       /* index at 24 */ < 8)) 
27068                                                 goto MATCH_label_c414;  /*opt-block+*/
27069                                               else 
27070                                                 goto MATCH_label_c413;  /*opt-block+*/
27071                                               
27072                                               break;
27073                                             case 5: 
27074                                               goto MATCH_label_c415; break;
27075                                             default: assert(0);
27076                                           } /* (MATCH_w_8_16 & 0x7) 
27077                                                 -- r_m at 16 --*/ 
27078                                         break;
27079                                       case 1: 
27080                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
27081                                         if ((MATCH_w_8_16 & 0x7) 
27082                                                 /* r_m at 16 */ == 4 && 
27083                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
27084                                                 /* index at 24 */ && 
27085                                           (MATCH_w_8_24 >> 3 & 0x7) 
27086                                                 /* index at 24 */ < 8)) { 
27087                                           unsigned Eaddr = 
27088                                             2 + addressToPC(MATCH_p);
27089                                           nextPC = 5 + MATCH_p; 
27090                                           
27091 #line 1175 "frontend/machine/pentium/decoder.m"
27092                                           
27093 
27094                                                 stmts = instantiate(pc,  "IMULow", DIS_EADDR16);
27095 
27096                                           
27097 
27098                                           
27099                                           
27100                                           
27101                                         } /*opt-block*//*opt-block+*/
27102                                         else 
27103                                           goto MATCH_label_c413;  /*opt-block+*/
27104                                         
27105                                         break;
27106                                       case 2: 
27107                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
27108                                         if ((MATCH_w_8_16 & 0x7) 
27109                                                 /* r_m at 16 */ == 4 && 
27110                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
27111                                                 /* index at 24 */ && 
27112                                           (MATCH_w_8_24 >> 3 & 0x7) 
27113                                                 /* index at 24 */ < 8)) 
27114                                           goto MATCH_label_c414;  /*opt-block+*/
27115                                         else 
27116                                           goto MATCH_label_c415;  /*opt-block+*/
27117                                         
27118                                         break;
27119                                       case 3: 
27120                                         goto MATCH_label_c412; break;
27121                                       default: assert(0);
27122                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
27123                                           -- mod at 16 --*/ 
27124                                   break;
27125                                 case 6: 
27126                                   
27127                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
27128                                           /* mod at 16 */) {
27129                                       case 0: 
27130                                         
27131                                           switch((MATCH_w_8_16 & 0x7) 
27132                                                 /* r_m at 16 */) {
27133                                             case 0: case 1: case 2: case 3: 
27134                                             case 6: case 7: 
27135                                               goto MATCH_label_c416; break;
27136                                             case 4: 
27137                                               MATCH_w_8_24 = 
27138                                                 getByte(3 + MATCH_p); 
27139                                               if ((MATCH_w_8_24 & 0x7) 
27140                                                       /* base at 24 */ == 5 && 
27141                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
27142                                                       /* index at 24 */ && 
27143                                                 (MATCH_w_8_24 >> 3 & 0x7) 
27144                                                       /* index at 24 */ < 8)) 
27145                                                 goto MATCH_label_c418;  /*opt-block+*/
27146                                               else 
27147                                                 goto MATCH_label_c417;  /*opt-block+*/
27148                                               
27149                                               break;
27150                                             case 5: 
27151                                               goto MATCH_label_c419; break;
27152                                             default: assert(0);
27153                                           } /* (MATCH_w_8_16 & 0x7) 
27154                                                 -- r_m at 16 --*/ 
27155                                         break;
27156                                       case 1: 
27157                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
27158                                         if ((MATCH_w_8_16 & 0x7) 
27159                                                 /* r_m at 16 */ == 4 && 
27160                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
27161                                                 /* index at 24 */ && 
27162                                           (MATCH_w_8_24 >> 3 & 0x7) 
27163                                                 /* index at 24 */ < 8)) { 
27164                                           unsigned Eaddr = 
27165                                             2 + addressToPC(MATCH_p);
27166                                           nextPC = 5 + MATCH_p; 
27167                                           
27168 #line 1199 "frontend/machine/pentium/decoder.m"
27169                                           
27170 
27171                                                 stmts = instantiate(pc,  "DIVAX", DIS_EADDR16);
27172 
27173                                           
27174 
27175                                           
27176                                           
27177                                           
27178                                         } /*opt-block*//*opt-block+*/
27179                                         else 
27180                                           goto MATCH_label_c417;  /*opt-block+*/
27181                                         
27182                                         break;
27183                                       case 2: 
27184                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
27185                                         if ((MATCH_w_8_16 & 0x7) 
27186                                                 /* r_m at 16 */ == 4 && 
27187                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
27188                                                 /* index at 24 */ && 
27189                                           (MATCH_w_8_24 >> 3 & 0x7) 
27190                                                 /* index at 24 */ < 8)) 
27191                                           goto MATCH_label_c418;  /*opt-block+*/
27192                                         else 
27193                                           goto MATCH_label_c419;  /*opt-block+*/
27194                                         
27195                                         break;
27196                                       case 3: 
27197                                         goto MATCH_label_c416; break;
27198                                       default: assert(0);
27199                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
27200                                           -- mod at 16 --*/ 
27201                                   break;
27202                                 case 7: 
27203                                   
27204                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
27205                                           /* mod at 16 */) {
27206                                       case 0: 
27207                                         
27208                                           switch((MATCH_w_8_16 & 0x7) 
27209                                                 /* r_m at 16 */) {
27210                                             case 0: case 1: case 2: case 3: 
27211                                             case 6: case 7: 
27212                                               goto MATCH_label_c420; break;
27213                                             case 4: 
27214                                               MATCH_w_8_24 = 
27215                                                 getByte(3 + MATCH_p); 
27216                                               if ((MATCH_w_8_24 & 0x7) 
27217                                                       /* base at 24 */ == 5 && 
27218                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
27219                                                       /* index at 24 */ && 
27220                                                 (MATCH_w_8_24 >> 3 & 0x7) 
27221                                                       /* index at 24 */ < 8)) 
27222                                                 goto MATCH_label_c422;  /*opt-block+*/
27223                                               else 
27224                                                 goto MATCH_label_c421;  /*opt-block+*/
27225                                               
27226                                               break;
27227                                             case 5: 
27228                                               goto MATCH_label_c423; break;
27229                                             default: assert(0);
27230                                           } /* (MATCH_w_8_16 & 0x7) 
27231                                                 -- r_m at 16 --*/ 
27232                                         break;
27233                                       case 1: 
27234                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
27235                                         if ((MATCH_w_8_16 & 0x7) 
27236                                                 /* r_m at 16 */ == 4 && 
27237                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
27238                                                 /* index at 24 */ && 
27239                                           (MATCH_w_8_24 >> 3 & 0x7) 
27240                                                 /* index at 24 */ < 8)) { 
27241                                           unsigned Eaddr = 
27242                                             2 + addressToPC(MATCH_p);
27243                                           nextPC = 5 + MATCH_p; 
27244                                           
27245 #line 1184 "frontend/machine/pentium/decoder.m"
27246                                           
27247 
27248                                                 stmts = instantiate(pc,  "IDIVAX", DIS_EADDR16);
27249 
27250                                           
27251 
27252                                           
27253                                           
27254                                           
27255                                         } /*opt-block*//*opt-block+*/
27256                                         else 
27257                                           goto MATCH_label_c421;  /*opt-block+*/
27258                                         
27259                                         break;
27260                                       case 2: 
27261                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
27262                                         if ((MATCH_w_8_16 & 0x7) 
27263                                                 /* r_m at 16 */ == 4 && 
27264                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
27265                                                 /* index at 24 */ && 
27266                                           (MATCH_w_8_24 >> 3 & 0x7) 
27267                                                 /* index at 24 */ < 8)) 
27268                                           goto MATCH_label_c422;  /*opt-block+*/
27269                                         else 
27270                                           goto MATCH_label_c423;  /*opt-block+*/
27271                                         
27272                                         break;
27273                                       case 3: 
27274                                         goto MATCH_label_c420; break;
27275                                       default: assert(0);
27276                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
27277                                           -- mod at 16 --*/ 
27278                                   break;
27279                                 default: assert(0);
27280                               } /* (MATCH_w_8_16 >> 3 & 0x7) 
27281                                     -- reg_opcode at 16 --*/ 
27282                             
27283                           } /*opt-block*/ 
27284                         else 
27285                           goto MATCH_label_c64;  /*opt-block+*/
27286                         break;
27287                       default: assert(0);
27288                     } /* (MATCH_w_8_8 >> 4 & 0xf) -- row at 8 --*/ 
27289                   
27290                   break;
27291                 default: assert(0);
27292               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
27293             break;
27294           case 7: 
27295             
27296               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
27297                 case 0: 
27298                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
27299                   { 
27300                     unsigned relocd = 
27301                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
27302                                   8) + addressToPC(MATCH_p);
27303                     nextPC = 2 + MATCH_p; 
27304                     
27305 #line 191 "frontend/machine/pentium/decoder.m"
27306                     
27307 
27308                             COND_JUMP("Jb.O", 2, relocd, (BRANCH_TYPE)0)
27309 
27310                     
27311 
27312                         /*
27313 
27314                          * Conditional branches, 16 bit offset: 66 0F 8X XX XX
27315 
27316                          */
27317 
27318                     
27319                     
27320                     
27321                   }
27322                   
27323                   break;
27324                 case 1: 
27325                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
27326                   { 
27327                     unsigned relocd = 
27328                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
27329                                   8) + addressToPC(MATCH_p);
27330                     nextPC = 2 + MATCH_p; 
27331                     
27332 #line 188 "frontend/machine/pentium/decoder.m"
27333                     
27334 
27335                             COND_JUMP("Jb.NO", 2, relocd, (BRANCH_TYPE)0)
27336 
27337                     
27338                     
27339                     
27340                   }
27341                   
27342                   break;
27343                 case 2: 
27344                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
27345                   { 
27346                     unsigned relocd = 
27347                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
27348                                   8) + addressToPC(MATCH_p);
27349                     nextPC = 2 + MATCH_p; 
27350                     
27351 #line 186 "frontend/machine/pentium/decoder.m"
27352                     
27353 
27354                             COND_JUMP("Jb.B", 2, relocd, BRANCH_JUL)
27355 
27356                     
27357                     
27358                     
27359                   }
27360                   
27361                   break;
27362                 case 3: 
27363                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
27364                   { 
27365                     unsigned relocd = 
27366                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
27367                                   8) + addressToPC(MATCH_p);
27368                     nextPC = 2 + MATCH_p; 
27369                     
27370 #line 184 "frontend/machine/pentium/decoder.m"
27371                     
27372 
27373                             COND_JUMP("Jb.NB", 2, relocd, BRANCH_JUGE)
27374 
27375                     
27376                     
27377                     
27378                   }
27379                   
27380                   break;
27381                 case 4: 
27382                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
27383                   { 
27384                     unsigned relocd = 
27385                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
27386                                   8) + addressToPC(MATCH_p);
27387                     nextPC = 2 + MATCH_p; 
27388                     
27389 #line 182 "frontend/machine/pentium/decoder.m"
27390                     
27391 
27392                             COND_JUMP("Jb.Z", 2, relocd, BRANCH_JE)
27393 
27394                     
27395                     
27396                     
27397                   }
27398                   
27399                   break;
27400                 case 5: 
27401                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
27402                   { 
27403                     unsigned relocd = 
27404                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
27405                                   8) + addressToPC(MATCH_p);
27406                     nextPC = 2 + MATCH_p; 
27407                     
27408 #line 180 "frontend/machine/pentium/decoder.m"
27409                     
27410 
27411                             COND_JUMP("Jb.NZ", 2, relocd, BRANCH_JNE)
27412 
27413                     
27414                     
27415                     
27416                   }
27417                   
27418                   break;
27419                 case 6: 
27420                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
27421                   { 
27422                     unsigned relocd = 
27423                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
27424                                   8) + addressToPC(MATCH_p);
27425                     nextPC = 2 + MATCH_p; 
27426                     
27427 #line 178 "frontend/machine/pentium/decoder.m"
27428                     
27429 
27430                             COND_JUMP("Jb.BE", 2, relocd, BRANCH_JULE)
27431 
27432                     
27433                     
27434                     
27435                   }
27436                   
27437                   break;
27438                 case 7: 
27439                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
27440                   { 
27441                     unsigned relocd = 
27442                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
27443                                   8) + addressToPC(MATCH_p);
27444                     nextPC = 2 + MATCH_p; 
27445                     
27446 #line 176 "frontend/machine/pentium/decoder.m"
27447                     
27448 
27449                             COND_JUMP("Jb.NBE", 2, relocd, BRANCH_JUG)
27450 
27451                     
27452                     
27453                     
27454                   }
27455                   
27456                   break;
27457                 default: assert(0);
27458               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
27459             break;
27460           case 8: 
27461             
27462               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
27463                 case 0: 
27464                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
27465                   
27466                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
27467                       case 0: 
27468                         
27469                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
27470                             case 0: 
27471                               
27472                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
27473                                   case 0: case 1: case 2: case 3: case 6: 
27474                                   case 7: 
27475                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27476                                     goto MATCH_label_c436; 
27477                                     
27478                                     break;
27479                                   case 4: 
27480                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27481                                     if ((MATCH_w_8_16 & 0x7) 
27482                                             /* base at 16 */ == 5 && 
27483                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27484                                             /* index at 16 */ && 
27485                                       (MATCH_w_8_16 >> 3 & 0x7) 
27486                                             /* index at 16 */ < 8)) { 
27487                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
27488                                       goto MATCH_label_c438; 
27489                                       
27490                                     } /*opt-block*/
27491                                     else { 
27492                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
27493                                       goto MATCH_label_c437; 
27494                                       
27495                                     } /*opt-block*/
27496                                     
27497                                     break;
27498                                   case 5: 
27499                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
27500                                     goto MATCH_label_c439; 
27501                                     
27502                                     break;
27503                                   default: assert(0);
27504                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
27505                               break;
27506                             case 1: 
27507                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27508                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27509                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27510                                       /* index at 16 */ && 
27511                                 (MATCH_w_8_16 >> 3 & 0x7) 
27512                                       /* index at 16 */ < 8)) { 
27513                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
27514                                 { 
27515                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
27516                                   int /* [~128..127] */ i8 = 
27517                                     sign_extend((MATCH_w_8_32 & 0xff) 
27518                                                       /* i8 at 32 */, 8);
27519                                   nextPC = 5 + MATCH_p; 
27520                                   
27521 #line 1669 "frontend/machine/pentium/decoder.m"
27522                                   
27523 
27524                                         stmts = instantiate(pc,  "ADDib", DIS_EADDR8, DIS_I8);
27525 
27526                                   
27527 
27528                                   
27529                                   
27530                                   
27531                                 }
27532                                 
27533                               } /*opt-block*/
27534                               else { 
27535                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
27536                                 goto MATCH_label_c437; 
27537                                 
27538                               } /*opt-block*/
27539                               
27540                               break;
27541                             case 2: 
27542                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27543                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27544                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27545                                       /* index at 16 */ && 
27546                                 (MATCH_w_8_16 >> 3 & 0x7) 
27547                                       /* index at 16 */ < 8)) { 
27548                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
27549                                 goto MATCH_label_c438; 
27550                                 
27551                               } /*opt-block*/
27552                               else { 
27553                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
27554                                 goto MATCH_label_c439; 
27555                                 
27556                               } /*opt-block*/
27557                               
27558                               break;
27559                             case 3: 
27560                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27561                               goto MATCH_label_c436; 
27562                               
27563                               break;
27564                             default: assert(0);
27565                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
27566                         break;
27567                       case 1: 
27568                         
27569                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
27570                             case 0: 
27571                               
27572                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
27573                                   case 0: case 1: case 2: case 3: case 6: 
27574                                   case 7: 
27575                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27576                                     goto MATCH_label_c440; 
27577                                     
27578                                     break;
27579                                   case 4: 
27580                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27581                                     if ((MATCH_w_8_16 & 0x7) 
27582                                             /* base at 16 */ == 5 && 
27583                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27584                                             /* index at 16 */ && 
27585                                       (MATCH_w_8_16 >> 3 & 0x7) 
27586                                             /* index at 16 */ < 8)) { 
27587                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
27588                                       goto MATCH_label_c442; 
27589                                       
27590                                     } /*opt-block*/
27591                                     else { 
27592                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
27593                                       goto MATCH_label_c441; 
27594                                       
27595                                     } /*opt-block*/
27596                                     
27597                                     break;
27598                                   case 5: 
27599                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
27600                                     goto MATCH_label_c443; 
27601                                     
27602                                     break;
27603                                   default: assert(0);
27604                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
27605                               break;
27606                             case 1: 
27607                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27608                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27609                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27610                                       /* index at 16 */ && 
27611                                 (MATCH_w_8_16 >> 3 & 0x7) 
27612                                       /* index at 16 */ < 8)) { 
27613                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
27614                                 { 
27615                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
27616                                   int /* [~128..127] */ i8 = 
27617                                     sign_extend((MATCH_w_8_32 & 0xff) 
27618                                                       /* i8 at 32 */, 8);
27619                                   nextPC = 5 + MATCH_p; 
27620                                   
27621 #line 1666 "frontend/machine/pentium/decoder.m"
27622                                   
27623 
27624                                         stmts = instantiate(pc,  "ORib", DIS_EADDR8, DIS_I8);
27625 
27626                                   
27627 
27628                                   
27629                                   
27630                                   
27631                                 }
27632                                 
27633                               } /*opt-block*/
27634                               else { 
27635                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
27636                                 goto MATCH_label_c441; 
27637                                 
27638                               } /*opt-block*/
27639                               
27640                               break;
27641                             case 2: 
27642                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27643                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27644                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27645                                       /* index at 16 */ && 
27646                                 (MATCH_w_8_16 >> 3 & 0x7) 
27647                                       /* index at 16 */ < 8)) { 
27648                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
27649                                 goto MATCH_label_c442; 
27650                                 
27651                               } /*opt-block*/
27652                               else { 
27653                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
27654                                 goto MATCH_label_c443; 
27655                                 
27656                               } /*opt-block*/
27657                               
27658                               break;
27659                             case 3: 
27660                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27661                               goto MATCH_label_c440; 
27662                               
27663                               break;
27664                             default: assert(0);
27665                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
27666                         break;
27667                       case 2: 
27668                         
27669                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
27670                             case 0: 
27671                               
27672                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
27673                                   case 0: case 1: case 2: case 3: case 6: 
27674                                   case 7: 
27675                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27676                                     goto MATCH_label_c444; 
27677                                     
27678                                     break;
27679                                   case 4: 
27680                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27681                                     if ((MATCH_w_8_16 & 0x7) 
27682                                             /* base at 16 */ == 5 && 
27683                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27684                                             /* index at 16 */ && 
27685                                       (MATCH_w_8_16 >> 3 & 0x7) 
27686                                             /* index at 16 */ < 8)) { 
27687                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
27688                                       goto MATCH_label_c446; 
27689                                       
27690                                     } /*opt-block*/
27691                                     else { 
27692                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
27693                                       goto MATCH_label_c445; 
27694                                       
27695                                     } /*opt-block*/
27696                                     
27697                                     break;
27698                                   case 5: 
27699                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
27700                                     goto MATCH_label_c447; 
27701                                     
27702                                     break;
27703                                   default: assert(0);
27704                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
27705                               break;
27706                             case 1: 
27707                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27708                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27709                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27710                                       /* index at 16 */ && 
27711                                 (MATCH_w_8_16 >> 3 & 0x7) 
27712                                       /* index at 16 */ < 8)) { 
27713                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
27714                                 { 
27715                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
27716                                   int /* [~128..127] */ i8 = 
27717                                     sign_extend((MATCH_w_8_32 & 0xff) 
27718                                                       /* i8 at 32 */, 8);
27719                                   nextPC = 5 + MATCH_p; 
27720                                   
27721 #line 1663 "frontend/machine/pentium/decoder.m"
27722                                   
27723 
27724                                         stmts = instantiate(pc,  "ADCib", DIS_EADDR8, DIS_I8);
27725 
27726                                   
27727 
27728                                   
27729                                   
27730                                   
27731                                 }
27732                                 
27733                               } /*opt-block*/
27734                               else { 
27735                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
27736                                 goto MATCH_label_c445; 
27737                                 
27738                               } /*opt-block*/
27739                               
27740                               break;
27741                             case 2: 
27742                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27743                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27744                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27745                                       /* index at 16 */ && 
27746                                 (MATCH_w_8_16 >> 3 & 0x7) 
27747                                       /* index at 16 */ < 8)) { 
27748                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
27749                                 goto MATCH_label_c446; 
27750                                 
27751                               } /*opt-block*/
27752                               else { 
27753                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
27754                                 goto MATCH_label_c447; 
27755                                 
27756                               } /*opt-block*/
27757                               
27758                               break;
27759                             case 3: 
27760                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27761                               goto MATCH_label_c444; 
27762                               
27763                               break;
27764                             default: assert(0);
27765                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
27766                         break;
27767                       case 3: 
27768                         
27769                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
27770                             case 0: 
27771                               
27772                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
27773                                   case 0: case 1: case 2: case 3: case 6: 
27774                                   case 7: 
27775                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27776                                     goto MATCH_label_c448; 
27777                                     
27778                                     break;
27779                                   case 4: 
27780                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27781                                     if ((MATCH_w_8_16 & 0x7) 
27782                                             /* base at 16 */ == 5 && 
27783                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27784                                             /* index at 16 */ && 
27785                                       (MATCH_w_8_16 >> 3 & 0x7) 
27786                                             /* index at 16 */ < 8)) { 
27787                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
27788                                       goto MATCH_label_c450; 
27789                                       
27790                                     } /*opt-block*/
27791                                     else { 
27792                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
27793                                       goto MATCH_label_c449; 
27794                                       
27795                                     } /*opt-block*/
27796                                     
27797                                     break;
27798                                   case 5: 
27799                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
27800                                     goto MATCH_label_c451; 
27801                                     
27802                                     break;
27803                                   default: assert(0);
27804                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
27805                               break;
27806                             case 1: 
27807                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27808                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27809                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27810                                       /* index at 16 */ && 
27811                                 (MATCH_w_8_16 >> 3 & 0x7) 
27812                                       /* index at 16 */ < 8)) { 
27813                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
27814                                 { 
27815                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
27816                                   int /* [~128..127] */ i8 = 
27817                                     sign_extend((MATCH_w_8_32 & 0xff) 
27818                                                       /* i8 at 32 */, 8);
27819                                   nextPC = 5 + MATCH_p; 
27820                                   
27821 #line 1660 "frontend/machine/pentium/decoder.m"
27822                                   
27823 
27824                                         stmts = instantiate(pc,  "SBBib", DIS_EADDR8, DIS_I8);
27825 
27826                                   
27827 
27828                                   
27829                                   
27830                                   
27831                                 }
27832                                 
27833                               } /*opt-block*/
27834                               else { 
27835                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
27836                                 goto MATCH_label_c449; 
27837                                 
27838                               } /*opt-block*/
27839                               
27840                               break;
27841                             case 2: 
27842                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27843                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27844                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27845                                       /* index at 16 */ && 
27846                                 (MATCH_w_8_16 >> 3 & 0x7) 
27847                                       /* index at 16 */ < 8)) { 
27848                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
27849                                 goto MATCH_label_c450; 
27850                                 
27851                               } /*opt-block*/
27852                               else { 
27853                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
27854                                 goto MATCH_label_c451; 
27855                                 
27856                               } /*opt-block*/
27857                               
27858                               break;
27859                             case 3: 
27860                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27861                               goto MATCH_label_c448; 
27862                               
27863                               break;
27864                             default: assert(0);
27865                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
27866                         break;
27867                       case 4: 
27868                         
27869                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
27870                             case 0: 
27871                               
27872                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
27873                                   case 0: case 1: case 2: case 3: case 6: 
27874                                   case 7: 
27875                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27876                                     goto MATCH_label_c452; 
27877                                     
27878                                     break;
27879                                   case 4: 
27880                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27881                                     if ((MATCH_w_8_16 & 0x7) 
27882                                             /* base at 16 */ == 5 && 
27883                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27884                                             /* index at 16 */ && 
27885                                       (MATCH_w_8_16 >> 3 & 0x7) 
27886                                             /* index at 16 */ < 8)) { 
27887                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
27888                                       goto MATCH_label_c454; 
27889                                       
27890                                     } /*opt-block*/
27891                                     else { 
27892                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
27893                                       goto MATCH_label_c453; 
27894                                       
27895                                     } /*opt-block*/
27896                                     
27897                                     break;
27898                                   case 5: 
27899                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
27900                                     goto MATCH_label_c455; 
27901                                     
27902                                     break;
27903                                   default: assert(0);
27904                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
27905                               break;
27906                             case 1: 
27907                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27908                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27909                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27910                                       /* index at 16 */ && 
27911                                 (MATCH_w_8_16 >> 3 & 0x7) 
27912                                       /* index at 16 */ < 8)) { 
27913                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
27914                                 { 
27915                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
27916                                   int /* [~128..127] */ i8 = 
27917                                     sign_extend((MATCH_w_8_32 & 0xff) 
27918                                                       /* i8 at 32 */, 8);
27919                                   nextPC = 5 + MATCH_p; 
27920                                   
27921 #line 1657 "frontend/machine/pentium/decoder.m"
27922                                   
27923 
27924                                         stmts = instantiate(pc,  "ANDib", DIS_EADDR8, DIS_I8);
27925 
27926                                   
27927 
27928                                   
27929                                   
27930                                   
27931                                 }
27932                                 
27933                               } /*opt-block*/
27934                               else { 
27935                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
27936                                 goto MATCH_label_c453; 
27937                                 
27938                               } /*opt-block*/
27939                               
27940                               break;
27941                             case 2: 
27942                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27943                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27944                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27945                                       /* index at 16 */ && 
27946                                 (MATCH_w_8_16 >> 3 & 0x7) 
27947                                       /* index at 16 */ < 8)) { 
27948                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
27949                                 goto MATCH_label_c454; 
27950                                 
27951                               } /*opt-block*/
27952                               else { 
27953                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
27954                                 goto MATCH_label_c455; 
27955                                 
27956                               } /*opt-block*/
27957                               
27958                               break;
27959                             case 3: 
27960                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27961                               goto MATCH_label_c452; 
27962                               
27963                               break;
27964                             default: assert(0);
27965                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
27966                         break;
27967                       case 5: 
27968                         
27969                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
27970                             case 0: 
27971                               
27972                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
27973                                   case 0: case 1: case 2: case 3: case 6: 
27974                                   case 7: 
27975                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27976                                     goto MATCH_label_c456; 
27977                                     
27978                                     break;
27979                                   case 4: 
27980                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27981                                     if ((MATCH_w_8_16 & 0x7) 
27982                                             /* base at 16 */ == 5 && 
27983                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27984                                             /* index at 16 */ && 
27985                                       (MATCH_w_8_16 >> 3 & 0x7) 
27986                                             /* index at 16 */ < 8)) { 
27987                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
27988                                       goto MATCH_label_c458; 
27989                                       
27990                                     } /*opt-block*/
27991                                     else { 
27992                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
27993                                       goto MATCH_label_c457; 
27994                                       
27995                                     } /*opt-block*/
27996                                     
27997                                     break;
27998                                   case 5: 
27999                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
28000                                     goto MATCH_label_c459; 
28001                                     
28002                                     break;
28003                                   default: assert(0);
28004                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28005                               break;
28006                             case 1: 
28007                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28008                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28009                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28010                                       /* index at 16 */ && 
28011                                 (MATCH_w_8_16 >> 3 & 0x7) 
28012                                       /* index at 16 */ < 8)) { 
28013                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
28014                                 { 
28015                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
28016                                   int /* [~128..127] */ i8 = 
28017                                     sign_extend((MATCH_w_8_32 & 0xff) 
28018                                                       /* i8 at 32 */, 8);
28019                                   nextPC = 5 + MATCH_p; 
28020                                   
28021 #line 1654 "frontend/machine/pentium/decoder.m"
28022                                   
28023 
28024                                         stmts = instantiate(pc,  "SUBib", DIS_EADDR8, DIS_I8);
28025 
28026                                   
28027 
28028                                   
28029                                   
28030                                   
28031                                 }
28032                                 
28033                               } /*opt-block*/
28034                               else { 
28035                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
28036                                 goto MATCH_label_c457; 
28037                                 
28038                               } /*opt-block*/
28039                               
28040                               break;
28041                             case 2: 
28042                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28043                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28044                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28045                                       /* index at 16 */ && 
28046                                 (MATCH_w_8_16 >> 3 & 0x7) 
28047                                       /* index at 16 */ < 8)) { 
28048                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
28049                                 goto MATCH_label_c458; 
28050                                 
28051                               } /*opt-block*/
28052                               else { 
28053                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
28054                                 goto MATCH_label_c459; 
28055                                 
28056                               } /*opt-block*/
28057                               
28058                               break;
28059                             case 3: 
28060                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28061                               goto MATCH_label_c456; 
28062                               
28063                               break;
28064                             default: assert(0);
28065                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28066                         break;
28067                       case 6: 
28068                         
28069                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28070                             case 0: 
28071                               
28072                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28073                                   case 0: case 1: case 2: case 3: case 6: 
28074                                   case 7: 
28075                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28076                                     goto MATCH_label_c460; 
28077                                     
28078                                     break;
28079                                   case 4: 
28080                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28081                                     if ((MATCH_w_8_16 & 0x7) 
28082                                             /* base at 16 */ == 5 && 
28083                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28084                                             /* index at 16 */ && 
28085                                       (MATCH_w_8_16 >> 3 & 0x7) 
28086                                             /* index at 16 */ < 8)) { 
28087                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
28088                                       goto MATCH_label_c462; 
28089                                       
28090                                     } /*opt-block*/
28091                                     else { 
28092                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
28093                                       goto MATCH_label_c461; 
28094                                       
28095                                     } /*opt-block*/
28096                                     
28097                                     break;
28098                                   case 5: 
28099                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
28100                                     goto MATCH_label_c463; 
28101                                     
28102                                     break;
28103                                   default: assert(0);
28104                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28105                               break;
28106                             case 1: 
28107                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28108                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28109                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28110                                       /* index at 16 */ && 
28111                                 (MATCH_w_8_16 >> 3 & 0x7) 
28112                                       /* index at 16 */ < 8)) { 
28113                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
28114                                 { 
28115                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
28116                                   int /* [~128..127] */ i8 = 
28117                                     sign_extend((MATCH_w_8_32 & 0xff) 
28118                                                       /* i8 at 32 */, 8);
28119                                   nextPC = 5 + MATCH_p; 
28120                                   
28121 #line 1651 "frontend/machine/pentium/decoder.m"
28122                                   
28123 
28124                                         stmts = instantiate(pc,  "XORib", DIS_EADDR8, DIS_I8);
28125 
28126                                   
28127 
28128                                   
28129                                   
28130                                   
28131                                 }
28132                                 
28133                               } /*opt-block*/
28134                               else { 
28135                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
28136                                 goto MATCH_label_c461; 
28137                                 
28138                               } /*opt-block*/
28139                               
28140                               break;
28141                             case 2: 
28142                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28143                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28144                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28145                                       /* index at 16 */ && 
28146                                 (MATCH_w_8_16 >> 3 & 0x7) 
28147                                       /* index at 16 */ < 8)) { 
28148                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
28149                                 goto MATCH_label_c462; 
28150                                 
28151                               } /*opt-block*/
28152                               else { 
28153                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
28154                                 goto MATCH_label_c463; 
28155                                 
28156                               } /*opt-block*/
28157                               
28158                               break;
28159                             case 3: 
28160                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28161                               goto MATCH_label_c460; 
28162                               
28163                               break;
28164                             default: assert(0);
28165                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28166                         break;
28167                       case 7: 
28168                         
28169                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28170                             case 0: 
28171                               
28172                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28173                                   case 0: case 1: case 2: case 3: case 6: 
28174                                   case 7: 
28175                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28176                                     goto MATCH_label_c464; 
28177                                     
28178                                     break;
28179                                   case 4: 
28180                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28181                                     if ((MATCH_w_8_16 & 0x7) 
28182                                             /* base at 16 */ == 5 && 
28183                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28184                                             /* index at 16 */ && 
28185                                       (MATCH_w_8_16 >> 3 & 0x7) 
28186                                             /* index at 16 */ < 8)) { 
28187                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
28188                                       goto MATCH_label_c466; 
28189                                       
28190                                     } /*opt-block*/
28191                                     else { 
28192                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
28193                                       goto MATCH_label_c465; 
28194                                       
28195                                     } /*opt-block*/
28196                                     
28197                                     break;
28198                                   case 5: 
28199                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
28200                                     goto MATCH_label_c467; 
28201                                     
28202                                     break;
28203                                   default: assert(0);
28204                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28205                               break;
28206                             case 1: 
28207                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28208                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28209                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28210                                       /* index at 16 */ && 
28211                                 (MATCH_w_8_16 >> 3 & 0x7) 
28212                                       /* index at 16 */ < 8)) { 
28213                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
28214                                 { 
28215                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
28216                                   int /* [~128..127] */ i8 = 
28217                                     sign_extend((MATCH_w_8_32 & 0xff) 
28218                                                       /* i8 at 32 */, 8);
28219                                   nextPC = 5 + MATCH_p; 
28220                                   
28221 #line 1648 "frontend/machine/pentium/decoder.m"
28222                                   
28223 
28224                                         stmts = instantiate(pc,  "CMPib", DIS_EADDR8, DIS_I8);
28225 
28226                                   
28227 
28228                                   
28229                                   
28230                                   
28231                                 }
28232                                 
28233                               } /*opt-block*/
28234                               else { 
28235                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
28236                                 goto MATCH_label_c465; 
28237                                 
28238                               } /*opt-block*/
28239                               
28240                               break;
28241                             case 2: 
28242                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28243                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28244                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28245                                       /* index at 16 */ && 
28246                                 (MATCH_w_8_16 >> 3 & 0x7) 
28247                                       /* index at 16 */ < 8)) { 
28248                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
28249                                 goto MATCH_label_c466; 
28250                                 
28251                               } /*opt-block*/
28252                               else { 
28253                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
28254                                 goto MATCH_label_c467; 
28255                                 
28256                               } /*opt-block*/
28257                               
28258                               break;
28259                             case 3: 
28260                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28261                               goto MATCH_label_c464; 
28262                               
28263                               break;
28264                             default: assert(0);
28265                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28266                         break;
28267                       default: assert(0);
28268                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
28269                   
28270                   break;
28271                 case 1: 
28272                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
28273                   
28274                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
28275                       case 0: 
28276                         
28277                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28278                             case 0: 
28279                               
28280                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28281                                   case 0: case 1: case 2: case 3: case 6: 
28282                                   case 7: 
28283                                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
28284                                     goto MATCH_label_c468; 
28285                                     
28286                                     break;
28287                                   case 4: 
28288                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28289                                     if ((MATCH_w_8_16 & 0x7) 
28290                                             /* base at 16 */ == 5 && 
28291                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28292                                             /* index at 16 */ && 
28293                                       (MATCH_w_8_16 >> 3 & 0x7) 
28294                                             /* index at 16 */ < 8)) { 
28295                                       MATCH_w_32_56 = getDword(7 + MATCH_p); 
28296                                       goto MATCH_label_c470; 
28297                                       
28298                                     } /*opt-block*/
28299                                     else { 
28300                                       MATCH_w_32_24 = getDword(3 + MATCH_p); 
28301                                       goto MATCH_label_c469; 
28302                                       
28303                                     } /*opt-block*/
28304                                     
28305                                     break;
28306                                   case 5: 
28307                                     MATCH_w_32_48 = getDword(6 + MATCH_p); 
28308                                     goto MATCH_label_c471; 
28309                                     
28310                                     break;
28311                                   default: assert(0);
28312                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28313                               break;
28314                             case 1: 
28315                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28316                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28317                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28318                                       /* index at 16 */ && 
28319                                 (MATCH_w_8_16 >> 3 & 0x7) 
28320                                       /* index at 16 */ < 8)) { 
28321                                 MATCH_w_32_32 = getDword(4 + MATCH_p); 
28322                                 { 
28323                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
28324                                   unsigned i32 = 
28325                                     MATCH_w_32_32 /* i32 at 32 */;
28326                                   nextPC = 8 + MATCH_p; 
28327                                   
28328 #line 1621 "frontend/machine/pentium/decoder.m"
28329                                   
28330 
28331                                         stmts = instantiate(pc,  "ADDid", DIS_EADDR32, DIS_I32);
28332 
28333                                   
28334 
28335                                   
28336                                   
28337                                   
28338                                 }
28339                                 
28340                               } /*opt-block*/
28341                               else { 
28342                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
28343                                 goto MATCH_label_c469; 
28344                                 
28345                               } /*opt-block*/
28346                               
28347                               break;
28348                             case 2: 
28349                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28350                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28351                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28352                                       /* index at 16 */ && 
28353                                 (MATCH_w_8_16 >> 3 & 0x7) 
28354                                       /* index at 16 */ < 8)) { 
28355                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
28356                                 goto MATCH_label_c470; 
28357                                 
28358                               } /*opt-block*/
28359                               else { 
28360                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
28361                                 goto MATCH_label_c471; 
28362                                 
28363                               } /*opt-block*/
28364                               
28365                               break;
28366                             case 3: 
28367                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
28368                               goto MATCH_label_c468; 
28369                               
28370                               break;
28371                             default: assert(0);
28372                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28373                         break;
28374                       case 1: 
28375                         
28376                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28377                             case 0: 
28378                               
28379                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28380                                   case 0: case 1: case 2: case 3: case 6: 
28381                                   case 7: 
28382                                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
28383                                     goto MATCH_label_c472; 
28384                                     
28385                                     break;
28386                                   case 4: 
28387                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28388                                     if ((MATCH_w_8_16 & 0x7) 
28389                                             /* base at 16 */ == 5 && 
28390                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28391                                             /* index at 16 */ && 
28392                                       (MATCH_w_8_16 >> 3 & 0x7) 
28393                                             /* index at 16 */ < 8)) { 
28394                                       MATCH_w_32_56 = getDword(7 + MATCH_p); 
28395                                       goto MATCH_label_c474; 
28396                                       
28397                                     } /*opt-block*/
28398                                     else { 
28399                                       MATCH_w_32_24 = getDword(3 + MATCH_p); 
28400                                       goto MATCH_label_c473; 
28401                                       
28402                                     } /*opt-block*/
28403                                     
28404                                     break;
28405                                   case 5: 
28406                                     MATCH_w_32_48 = getDword(6 + MATCH_p); 
28407                                     goto MATCH_label_c475; 
28408                                     
28409                                     break;
28410                                   default: assert(0);
28411                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28412                               break;
28413                             case 1: 
28414                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28415                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28416                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28417                                       /* index at 16 */ && 
28418                                 (MATCH_w_8_16 >> 3 & 0x7) 
28419                                       /* index at 16 */ < 8)) { 
28420                                 MATCH_w_32_32 = getDword(4 + MATCH_p); 
28421                                 { 
28422                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
28423                                   unsigned i32 = 
28424                                     MATCH_w_32_32 /* i32 at 32 */;
28425                                   nextPC = 8 + MATCH_p; 
28426                                   
28427 #line 1618 "frontend/machine/pentium/decoder.m"
28428                                   
28429 
28430                                         stmts = instantiate(pc,  "ORid", DIS_EADDR32, DIS_I32);
28431 
28432                                   
28433 
28434                                   
28435                                   
28436                                   
28437                                 }
28438                                 
28439                               } /*opt-block*/
28440                               else { 
28441                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
28442                                 goto MATCH_label_c473; 
28443                                 
28444                               } /*opt-block*/
28445                               
28446                               break;
28447                             case 2: 
28448                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28449                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28450                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28451                                       /* index at 16 */ && 
28452                                 (MATCH_w_8_16 >> 3 & 0x7) 
28453                                       /* index at 16 */ < 8)) { 
28454                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
28455                                 goto MATCH_label_c474; 
28456                                 
28457                               } /*opt-block*/
28458                               else { 
28459                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
28460                                 goto MATCH_label_c475; 
28461                                 
28462                               } /*opt-block*/
28463                               
28464                               break;
28465                             case 3: 
28466                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
28467                               goto MATCH_label_c472; 
28468                               
28469                               break;
28470                             default: assert(0);
28471                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28472                         break;
28473                       case 2: 
28474                         
28475                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28476                             case 0: 
28477                               
28478                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28479                                   case 0: case 1: case 2: case 3: case 6: 
28480                                   case 7: 
28481                                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
28482                                     goto MATCH_label_c476; 
28483                                     
28484                                     break;
28485                                   case 4: 
28486                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28487                                     if ((MATCH_w_8_16 & 0x7) 
28488                                             /* base at 16 */ == 5 && 
28489                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28490                                             /* index at 16 */ && 
28491                                       (MATCH_w_8_16 >> 3 & 0x7) 
28492                                             /* index at 16 */ < 8)) { 
28493                                       MATCH_w_32_56 = getDword(7 + MATCH_p); 
28494                                       goto MATCH_label_c478; 
28495                                       
28496                                     } /*opt-block*/
28497                                     else { 
28498                                       MATCH_w_32_24 = getDword(3 + MATCH_p); 
28499                                       goto MATCH_label_c477; 
28500                                       
28501                                     } /*opt-block*/
28502                                     
28503                                     break;
28504                                   case 5: 
28505                                     MATCH_w_32_48 = getDword(6 + MATCH_p); 
28506                                     goto MATCH_label_c479; 
28507                                     
28508                                     break;
28509                                   default: assert(0);
28510                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28511                               break;
28512                             case 1: 
28513                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28514                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28515                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28516                                       /* index at 16 */ && 
28517                                 (MATCH_w_8_16 >> 3 & 0x7) 
28518                                       /* index at 16 */ < 8)) { 
28519                                 MATCH_w_32_32 = getDword(4 + MATCH_p); 
28520                                 { 
28521                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
28522                                   unsigned i32 = 
28523                                     MATCH_w_32_32 /* i32 at 32 */;
28524                                   nextPC = 8 + MATCH_p; 
28525                                   
28526 #line 1615 "frontend/machine/pentium/decoder.m"
28527                                   
28528 
28529                                         stmts = instantiate(pc,  "ADCid", DIS_EADDR32, DIS_I32);
28530 
28531                                   
28532 
28533                                   
28534                                   
28535                                   
28536                                 }
28537                                 
28538                               } /*opt-block*/
28539                               else { 
28540                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
28541                                 goto MATCH_label_c477; 
28542                                 
28543                               } /*opt-block*/
28544                               
28545                               break;
28546                             case 2: 
28547                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28548                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28549                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28550                                       /* index at 16 */ && 
28551                                 (MATCH_w_8_16 >> 3 & 0x7) 
28552                                       /* index at 16 */ < 8)) { 
28553                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
28554                                 goto MATCH_label_c478; 
28555                                 
28556                               } /*opt-block*/
28557                               else { 
28558                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
28559                                 goto MATCH_label_c479; 
28560                                 
28561                               } /*opt-block*/
28562                               
28563                               break;
28564                             case 3: 
28565                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
28566                               goto MATCH_label_c476; 
28567                               
28568                               break;
28569                             default: assert(0);
28570                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28571                         break;
28572                       case 3: 
28573                         
28574                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28575                             case 0: 
28576                               
28577                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28578                                   case 0: case 1: case 2: case 3: case 6: 
28579                                   case 7: 
28580                                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
28581                                     goto MATCH_label_c480; 
28582                                     
28583                                     break;
28584                                   case 4: 
28585                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28586                                     if ((MATCH_w_8_16 & 0x7) 
28587                                             /* base at 16 */ == 5 && 
28588                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28589                                             /* index at 16 */ && 
28590                                       (MATCH_w_8_16 >> 3 & 0x7) 
28591                                             /* index at 16 */ < 8)) { 
28592                                       MATCH_w_32_56 = getDword(7 + MATCH_p); 
28593                                       goto MATCH_label_c482; 
28594                                       
28595                                     } /*opt-block*/
28596                                     else { 
28597                                       MATCH_w_32_24 = getDword(3 + MATCH_p); 
28598                                       goto MATCH_label_c481; 
28599                                       
28600                                     } /*opt-block*/
28601                                     
28602                                     break;
28603                                   case 5: 
28604                                     MATCH_w_32_48 = getDword(6 + MATCH_p); 
28605                                     goto MATCH_label_c483; 
28606                                     
28607                                     break;
28608                                   default: assert(0);
28609                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28610                               break;
28611                             case 1: 
28612                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28613                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28614                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28615                                       /* index at 16 */ && 
28616                                 (MATCH_w_8_16 >> 3 & 0x7) 
28617                                       /* index at 16 */ < 8)) { 
28618                                 MATCH_w_32_32 = getDword(4 + MATCH_p); 
28619                                 { 
28620                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
28621                                   unsigned i32 = 
28622                                     MATCH_w_32_32 /* i32 at 32 */;
28623                                   nextPC = 8 + MATCH_p; 
28624                                   
28625 #line 1612 "frontend/machine/pentium/decoder.m"
28626                                   
28627 
28628                                         stmts = instantiate(pc,  "SBBid", DIS_EADDR32, DIS_I32);
28629 
28630                                   
28631 
28632                                   
28633                                   
28634                                   
28635                                 }
28636                                 
28637                               } /*opt-block*/
28638                               else { 
28639                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
28640                                 goto MATCH_label_c481; 
28641                                 
28642                               } /*opt-block*/
28643                               
28644                               break;
28645                             case 2: 
28646                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28647                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28648                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28649                                       /* index at 16 */ && 
28650                                 (MATCH_w_8_16 >> 3 & 0x7) 
28651                                       /* index at 16 */ < 8)) { 
28652                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
28653                                 goto MATCH_label_c482; 
28654                                 
28655                               } /*opt-block*/
28656                               else { 
28657                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
28658                                 goto MATCH_label_c483; 
28659                                 
28660                               } /*opt-block*/
28661                               
28662                               break;
28663                             case 3: 
28664                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
28665                               goto MATCH_label_c480; 
28666                               
28667                               break;
28668                             default: assert(0);
28669                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28670                         break;
28671                       case 4: 
28672                         
28673                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28674                             case 0: 
28675                               
28676                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28677                                   case 0: case 1: case 2: case 3: case 6: 
28678                                   case 7: 
28679                                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
28680                                     goto MATCH_label_c484; 
28681                                     
28682                                     break;
28683                                   case 4: 
28684                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28685                                     if ((MATCH_w_8_16 & 0x7) 
28686                                             /* base at 16 */ == 5 && 
28687                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28688                                             /* index at 16 */ && 
28689                                       (MATCH_w_8_16 >> 3 & 0x7) 
28690                                             /* index at 16 */ < 8)) { 
28691                                       MATCH_w_32_56 = getDword(7 + MATCH_p); 
28692                                       goto MATCH_label_c486; 
28693                                       
28694                                     } /*opt-block*/
28695                                     else { 
28696                                       MATCH_w_32_24 = getDword(3 + MATCH_p); 
28697                                       goto MATCH_label_c485; 
28698                                       
28699                                     } /*opt-block*/
28700                                     
28701                                     break;
28702                                   case 5: 
28703                                     MATCH_w_32_48 = getDword(6 + MATCH_p); 
28704                                     goto MATCH_label_c487; 
28705                                     
28706                                     break;
28707                                   default: assert(0);
28708                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28709                               break;
28710                             case 1: 
28711                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28712                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28713                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28714                                       /* index at 16 */ && 
28715                                 (MATCH_w_8_16 >> 3 & 0x7) 
28716                                       /* index at 16 */ < 8)) { 
28717                                 MATCH_w_32_32 = getDword(4 + MATCH_p); 
28718                                 { 
28719                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
28720                                   unsigned i32 = 
28721                                     MATCH_w_32_32 /* i32 at 32 */;
28722                                   nextPC = 8 + MATCH_p; 
28723                                   
28724 #line 1609 "frontend/machine/pentium/decoder.m"
28725                                   
28726 
28727                                         stmts = instantiate(pc,  "ANDid", DIS_EADDR32, DIS_I32);
28728 
28729                                   
28730 
28731                                   
28732                                   
28733                                   
28734                                 }
28735                                 
28736                               } /*opt-block*/
28737                               else { 
28738                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
28739                                 goto MATCH_label_c485; 
28740                                 
28741                               } /*opt-block*/
28742                               
28743                               break;
28744                             case 2: 
28745                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28746                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28747                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28748                                       /* index at 16 */ && 
28749                                 (MATCH_w_8_16 >> 3 & 0x7) 
28750                                       /* index at 16 */ < 8)) { 
28751                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
28752                                 goto MATCH_label_c486; 
28753                                 
28754                               } /*opt-block*/
28755                               else { 
28756                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
28757                                 goto MATCH_label_c487; 
28758                                 
28759                               } /*opt-block*/
28760                               
28761                               break;
28762                             case 3: 
28763                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
28764                               goto MATCH_label_c484; 
28765                               
28766                               break;
28767                             default: assert(0);
28768                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28769                         break;
28770                       case 5: 
28771                         
28772                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28773                             case 0: 
28774                               
28775                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28776                                   case 0: case 1: case 2: case 3: case 6: 
28777                                   case 7: 
28778                                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
28779                                     goto MATCH_label_c488; 
28780                                     
28781                                     break;
28782                                   case 4: 
28783                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28784                                     if ((MATCH_w_8_16 & 0x7) 
28785                                             /* base at 16 */ == 5 && 
28786                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28787                                             /* index at 16 */ && 
28788                                       (MATCH_w_8_16 >> 3 & 0x7) 
28789                                             /* index at 16 */ < 8)) { 
28790                                       MATCH_w_32_56 = getDword(7 + MATCH_p); 
28791                                       goto MATCH_label_c490; 
28792                                       
28793                                     } /*opt-block*/
28794                                     else { 
28795                                       MATCH_w_32_24 = getDword(3 + MATCH_p); 
28796                                       goto MATCH_label_c489; 
28797                                       
28798                                     } /*opt-block*/
28799                                     
28800                                     break;
28801                                   case 5: 
28802                                     MATCH_w_32_48 = getDword(6 + MATCH_p); 
28803                                     goto MATCH_label_c491; 
28804                                     
28805                                     break;
28806                                   default: assert(0);
28807                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28808                               break;
28809                             case 1: 
28810                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28811                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28812                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28813                                       /* index at 16 */ && 
28814                                 (MATCH_w_8_16 >> 3 & 0x7) 
28815                                       /* index at 16 */ < 8)) { 
28816                                 MATCH_w_32_32 = getDword(4 + MATCH_p); 
28817                                 { 
28818                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
28819                                   unsigned i32 = 
28820                                     MATCH_w_32_32 /* i32 at 32 */;
28821                                   nextPC = 8 + MATCH_p; 
28822                                   
28823 #line 1606 "frontend/machine/pentium/decoder.m"
28824                                   
28825 
28826                                         stmts = instantiate(pc,  "SUBid", DIS_EADDR32, DIS_I32);
28827 
28828                                   
28829 
28830                                   
28831                                   
28832                                   
28833                                 }
28834                                 
28835                               } /*opt-block*/
28836                               else { 
28837                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
28838                                 goto MATCH_label_c489; 
28839                                 
28840                               } /*opt-block*/
28841                               
28842                               break;
28843                             case 2: 
28844                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28845                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28846                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28847                                       /* index at 16 */ && 
28848                                 (MATCH_w_8_16 >> 3 & 0x7) 
28849                                       /* index at 16 */ < 8)) { 
28850                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
28851                                 goto MATCH_label_c490; 
28852                                 
28853                               } /*opt-block*/
28854                               else { 
28855                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
28856                                 goto MATCH_label_c491; 
28857                                 
28858                               } /*opt-block*/
28859                               
28860                               break;
28861                             case 3: 
28862                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
28863                               goto MATCH_label_c488; 
28864                               
28865                               break;
28866                             default: assert(0);
28867                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28868                         break;
28869                       case 6: 
28870                         
28871                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28872                             case 0: 
28873                               
28874                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28875                                   case 0: case 1: case 2: case 3: case 6: 
28876                                   case 7: 
28877                                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
28878                                     goto MATCH_label_c492; 
28879                                     
28880                                     break;
28881                                   case 4: 
28882                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28883                                     if ((MATCH_w_8_16 & 0x7) 
28884                                             /* base at 16 */ == 5 && 
28885                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28886                                             /* index at 16 */ && 
28887                                       (MATCH_w_8_16 >> 3 & 0x7) 
28888                                             /* index at 16 */ < 8)) { 
28889                                       MATCH_w_32_56 = getDword(7 + MATCH_p); 
28890                                       goto MATCH_label_c494; 
28891                                       
28892                                     } /*opt-block*/
28893                                     else { 
28894                                       MATCH_w_32_24 = getDword(3 + MATCH_p); 
28895                                       goto MATCH_label_c493; 
28896                                       
28897                                     } /*opt-block*/
28898                                     
28899                                     break;
28900                                   case 5: 
28901                                     MATCH_w_32_48 = getDword(6 + MATCH_p); 
28902                                     goto MATCH_label_c495; 
28903                                     
28904                                     break;
28905                                   default: assert(0);
28906                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28907                               break;
28908                             case 1: 
28909                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28910                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28911                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28912                                       /* index at 16 */ && 
28913                                 (MATCH_w_8_16 >> 3 & 0x7) 
28914                                       /* index at 16 */ < 8)) { 
28915                                 MATCH_w_32_32 = getDword(4 + MATCH_p); 
28916                                 { 
28917                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
28918                                   unsigned i32 = 
28919                                     MATCH_w_32_32 /* i32 at 32 */;
28920                                   nextPC = 8 + MATCH_p; 
28921                                   
28922 #line 1603 "frontend/machine/pentium/decoder.m"
28923                                   
28924 
28925                                         stmts = instantiate(pc,  "XORid", DIS_EADDR32, DIS_I32);
28926 
28927                                   
28928 
28929                                   
28930                                   
28931                                   
28932                                 }
28933                                 
28934                               } /*opt-block*/
28935                               else { 
28936                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
28937                                 goto MATCH_label_c493; 
28938                                 
28939                               } /*opt-block*/
28940                               
28941                               break;
28942                             case 2: 
28943                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28944                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28945                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28946                                       /* index at 16 */ && 
28947                                 (MATCH_w_8_16 >> 3 & 0x7) 
28948                                       /* index at 16 */ < 8)) { 
28949                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
28950                                 goto MATCH_label_c494; 
28951                                 
28952                               } /*opt-block*/
28953                               else { 
28954                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
28955                                 goto MATCH_label_c495; 
28956                                 
28957                               } /*opt-block*/
28958                               
28959                               break;
28960                             case 3: 
28961                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
28962                               goto MATCH_label_c492; 
28963                               
28964                               break;
28965                             default: assert(0);
28966                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28967                         break;
28968                       case 7: 
28969                         
28970                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28971                             case 0: 
28972                               
28973                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28974                                   case 0: case 1: case 2: case 3: case 6: 
28975                                   case 7: 
28976                                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
28977                                     goto MATCH_label_c496; 
28978                                     
28979                                     break;
28980                                   case 4: 
28981                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28982                                     if ((MATCH_w_8_16 & 0x7) 
28983                                             /* base at 16 */ == 5 && 
28984                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28985                                             /* index at 16 */ && 
28986                                       (MATCH_w_8_16 >> 3 & 0x7) 
28987                                             /* index at 16 */ < 8)) { 
28988                                       MATCH_w_32_56 = getDword(7 + MATCH_p); 
28989                                       goto MATCH_label_c498; 
28990                                       
28991                                     } /*opt-block*/
28992                                     else { 
28993                                       MATCH_w_32_24 = getDword(3 + MATCH_p); 
28994                                       goto MATCH_label_c497; 
28995                                       
28996                                     } /*opt-block*/
28997                                     
28998                                     break;
28999                                   case 5: 
29000                                     MATCH_w_32_48 = getDword(6 + MATCH_p); 
29001                                     goto MATCH_label_c499; 
29002                                     
29003                                     break;
29004                                   default: assert(0);
29005                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29006                               break;
29007                             case 1: 
29008                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29009                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29010                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29011                                       /* index at 16 */ && 
29012                                 (MATCH_w_8_16 >> 3 & 0x7) 
29013                                       /* index at 16 */ < 8)) { 
29014                                 MATCH_w_32_32 = getDword(4 + MATCH_p); 
29015                                 { 
29016                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
29017                                   unsigned i32 = 
29018                                     MATCH_w_32_32 /* i32 at 32 */;
29019                                   nextPC = 8 + MATCH_p; 
29020                                   
29021 #line 1600 "frontend/machine/pentium/decoder.m"
29022                                   
29023 
29024                                         stmts = instantiate(pc,  "CMPid", DIS_EADDR32, DIS_I32);
29025 
29026                                   
29027 
29028                                   
29029                                   
29030                                   
29031                                 }
29032                                 
29033                               } /*opt-block*/
29034                               else { 
29035                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
29036                                 goto MATCH_label_c497; 
29037                                 
29038                               } /*opt-block*/
29039                               
29040                               break;
29041                             case 2: 
29042                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29043                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29044                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29045                                       /* index at 16 */ && 
29046                                 (MATCH_w_8_16 >> 3 & 0x7) 
29047                                       /* index at 16 */ < 8)) { 
29048                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
29049                                 goto MATCH_label_c498; 
29050                                 
29051                               } /*opt-block*/
29052                               else { 
29053                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
29054                                 goto MATCH_label_c499; 
29055                                 
29056                               } /*opt-block*/
29057                               
29058                               break;
29059                             case 3: 
29060                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
29061                               goto MATCH_label_c496; 
29062                               
29063                               break;
29064                             default: assert(0);
29065                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29066                         break;
29067                       default: assert(0);
29068                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
29069                   
29070                   break;
29071                 case 2: 
29072                   goto MATCH_label_c64; break;
29073                 case 3: 
29074                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
29075                   
29076                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
29077                       case 0: 
29078                         
29079                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29080                             case 0: 
29081                               
29082                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29083                                   case 0: case 1: case 2: case 3: case 6: 
29084                                   case 7: 
29085                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29086                                     goto MATCH_label_c500; 
29087                                     
29088                                     break;
29089                                   case 4: 
29090                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29091                                     if ((MATCH_w_8_16 & 0x7) 
29092                                             /* base at 16 */ == 5 && 
29093                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29094                                             /* index at 16 */ && 
29095                                       (MATCH_w_8_16 >> 3 & 0x7) 
29096                                             /* index at 16 */ < 8)) { 
29097                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
29098                                       goto MATCH_label_c502; 
29099                                       
29100                                     } /*opt-block*/
29101                                     else { 
29102                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
29103                                       goto MATCH_label_c501; 
29104                                       
29105                                     } /*opt-block*/
29106                                     
29107                                     break;
29108                                   case 5: 
29109                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
29110                                     goto MATCH_label_c503; 
29111                                     
29112                                     break;
29113                                   default: assert(0);
29114                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29115                               break;
29116                             case 1: 
29117                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29118                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29119                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29120                                       /* index at 16 */ && 
29121                                 (MATCH_w_8_16 >> 3 & 0x7) 
29122                                       /* index at 16 */ < 8)) { 
29123                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
29124                                 { 
29125                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
29126                                   int /* [~128..127] */ i8 = 
29127                                     sign_extend((MATCH_w_8_32 & 0xff) 
29128                                                       /* i8 at 32 */, 8);
29129                                   nextPC = 5 + MATCH_p; 
29130                                   
29131 #line 1594 "frontend/machine/pentium/decoder.m"
29132                                   
29133 
29134                                         stmts = instantiate(pc,  "ADDiodb", DIS_EADDR32, DIS_I8);
29135 
29136                                   
29137 
29138                                   
29139                                   
29140                                   
29141                                 }
29142                                 
29143                               } /*opt-block*/
29144                               else { 
29145                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
29146                                 goto MATCH_label_c501; 
29147                                 
29148                               } /*opt-block*/
29149                               
29150                               break;
29151                             case 2: 
29152                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29153                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29154                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29155                                       /* index at 16 */ && 
29156                                 (MATCH_w_8_16 >> 3 & 0x7) 
29157                                       /* index at 16 */ < 8)) { 
29158                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
29159                                 goto MATCH_label_c502; 
29160                                 
29161                               } /*opt-block*/
29162                               else { 
29163                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
29164                                 goto MATCH_label_c503; 
29165                                 
29166                               } /*opt-block*/
29167                               
29168                               break;
29169                             case 3: 
29170                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29171                               goto MATCH_label_c500; 
29172                               
29173                               break;
29174                             default: assert(0);
29175                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29176                         break;
29177                       case 1: 
29178                         
29179                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29180                             case 0: 
29181                               
29182                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29183                                   case 0: case 1: case 2: case 3: case 6: 
29184                                   case 7: 
29185                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29186                                     goto MATCH_label_c504; 
29187                                     
29188                                     break;
29189                                   case 4: 
29190                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29191                                     if ((MATCH_w_8_16 & 0x7) 
29192                                             /* base at 16 */ == 5 && 
29193                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29194                                             /* index at 16 */ && 
29195                                       (MATCH_w_8_16 >> 3 & 0x7) 
29196                                             /* index at 16 */ < 8)) { 
29197                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
29198                                       goto MATCH_label_c506; 
29199                                       
29200                                     } /*opt-block*/
29201                                     else { 
29202                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
29203                                       goto MATCH_label_c505; 
29204                                       
29205                                     } /*opt-block*/
29206                                     
29207                                     break;
29208                                   case 5: 
29209                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
29210                                     goto MATCH_label_c507; 
29211                                     
29212                                     break;
29213                                   default: assert(0);
29214                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29215                               break;
29216                             case 1: 
29217                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29218                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29219                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29220                                       /* index at 16 */ && 
29221                                 (MATCH_w_8_16 >> 3 & 0x7) 
29222                                       /* index at 16 */ < 8)) { 
29223                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
29224                                 { 
29225                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
29226                                   int /* [~128..127] */ i8 = 
29227                                     sign_extend((MATCH_w_8_32 & 0xff) 
29228                                                       /* i8 at 32 */, 8);
29229                                   nextPC = 5 + MATCH_p; 
29230                                   
29231 #line 1588 "frontend/machine/pentium/decoder.m"
29232                                   
29233 
29234                                         stmts = instantiate(pc,  "ORiodb", DIS_EADDR32, DIS_I8);
29235 
29236                                   
29237 
29238                                   
29239                                   
29240                                   
29241                                 }
29242                                 
29243                               } /*opt-block*/
29244                               else { 
29245                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
29246                                 goto MATCH_label_c505; 
29247                                 
29248                               } /*opt-block*/
29249                               
29250                               break;
29251                             case 2: 
29252                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29253                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29254                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29255                                       /* index at 16 */ && 
29256                                 (MATCH_w_8_16 >> 3 & 0x7) 
29257                                       /* index at 16 */ < 8)) { 
29258                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
29259                                 goto MATCH_label_c506; 
29260                                 
29261                               } /*opt-block*/
29262                               else { 
29263                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
29264                                 goto MATCH_label_c507; 
29265                                 
29266                               } /*opt-block*/
29267                               
29268                               break;
29269                             case 3: 
29270                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29271                               goto MATCH_label_c504; 
29272                               
29273                               break;
29274                             default: assert(0);
29275                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29276                         break;
29277                       case 2: 
29278                         
29279                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29280                             case 0: 
29281                               
29282                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29283                                   case 0: case 1: case 2: case 3: case 6: 
29284                                   case 7: 
29285                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29286                                     goto MATCH_label_c508; 
29287                                     
29288                                     break;
29289                                   case 4: 
29290                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29291                                     if ((MATCH_w_8_16 & 0x7) 
29292                                             /* base at 16 */ == 5 && 
29293                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29294                                             /* index at 16 */ && 
29295                                       (MATCH_w_8_16 >> 3 & 0x7) 
29296                                             /* index at 16 */ < 8)) { 
29297                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
29298                                       goto MATCH_label_c510; 
29299                                       
29300                                     } /*opt-block*/
29301                                     else { 
29302                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
29303                                       goto MATCH_label_c509; 
29304                                       
29305                                     } /*opt-block*/
29306                                     
29307                                     break;
29308                                   case 5: 
29309                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
29310                                     goto MATCH_label_c511; 
29311                                     
29312                                     break;
29313                                   default: assert(0);
29314                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29315                               break;
29316                             case 1: 
29317                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29318                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29319                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29320                                       /* index at 16 */ && 
29321                                 (MATCH_w_8_16 >> 3 & 0x7) 
29322                                       /* index at 16 */ < 8)) { 
29323                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
29324                                 { 
29325                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
29326                                   int /* [~128..127] */ i8 = 
29327                                     sign_extend((MATCH_w_8_32 & 0xff) 
29328                                                       /* i8 at 32 */, 8);
29329                                   nextPC = 5 + MATCH_p; 
29330                                   
29331 #line 1582 "frontend/machine/pentium/decoder.m"
29332                                   
29333 
29334                                         stmts = instantiate(pc,  "ADCiodb", DIS_EADDR32, DIS_I8);
29335 
29336                                   
29337 
29338                                   
29339                                   
29340                                   
29341                                 }
29342                                 
29343                               } /*opt-block*/
29344                               else { 
29345                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
29346                                 goto MATCH_label_c509; 
29347                                 
29348                               } /*opt-block*/
29349                               
29350                               break;
29351                             case 2: 
29352                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29353                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29354                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29355                                       /* index at 16 */ && 
29356                                 (MATCH_w_8_16 >> 3 & 0x7) 
29357                                       /* index at 16 */ < 8)) { 
29358                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
29359                                 goto MATCH_label_c510; 
29360                                 
29361                               } /*opt-block*/
29362                               else { 
29363                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
29364                                 goto MATCH_label_c511; 
29365                                 
29366                               } /*opt-block*/
29367                               
29368                               break;
29369                             case 3: 
29370                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29371                               goto MATCH_label_c508; 
29372                               
29373                               break;
29374                             default: assert(0);
29375                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29376                         break;
29377                       case 3: 
29378                         
29379                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29380                             case 0: 
29381                               
29382                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29383                                   case 0: case 1: case 2: case 3: case 6: 
29384                                   case 7: 
29385                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29386                                     goto MATCH_label_c512; 
29387                                     
29388                                     break;
29389                                   case 4: 
29390                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29391                                     if ((MATCH_w_8_16 & 0x7) 
29392                                             /* base at 16 */ == 5 && 
29393                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29394                                             /* index at 16 */ && 
29395                                       (MATCH_w_8_16 >> 3 & 0x7) 
29396                                             /* index at 16 */ < 8)) { 
29397                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
29398                                       goto MATCH_label_c514; 
29399                                       
29400                                     } /*opt-block*/
29401                                     else { 
29402                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
29403                                       goto MATCH_label_c513; 
29404                                       
29405                                     } /*opt-block*/
29406                                     
29407                                     break;
29408                                   case 5: 
29409                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
29410                                     goto MATCH_label_c515; 
29411                                     
29412                                     break;
29413                                   default: assert(0);
29414                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29415                               break;
29416                             case 1: 
29417                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29418                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29419                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29420                                       /* index at 16 */ && 
29421                                 (MATCH_w_8_16 >> 3 & 0x7) 
29422                                       /* index at 16 */ < 8)) { 
29423                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
29424                                 { 
29425                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
29426                                   int /* [~128..127] */ i8 = 
29427                                     sign_extend((MATCH_w_8_32 & 0xff) 
29428                                                       /* i8 at 32 */, 8);
29429                                   nextPC = 5 + MATCH_p; 
29430                                   
29431 #line 1576 "frontend/machine/pentium/decoder.m"
29432                                   
29433 
29434                                         stmts = instantiate(pc,  "SBBiodb", DIS_EADDR32, DIS_I8);
29435 
29436                                   
29437 
29438                                   
29439                                   
29440                                   
29441                                 }
29442                                 
29443                               } /*opt-block*/
29444                               else { 
29445                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
29446                                 goto MATCH_label_c513; 
29447                                 
29448                               } /*opt-block*/
29449                               
29450                               break;
29451                             case 2: 
29452                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29453                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29454                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29455                                       /* index at 16 */ && 
29456                                 (MATCH_w_8_16 >> 3 & 0x7) 
29457                                       /* index at 16 */ < 8)) { 
29458                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
29459                                 goto MATCH_label_c514; 
29460                                 
29461                               } /*opt-block*/
29462                               else { 
29463                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
29464                                 goto MATCH_label_c515; 
29465                                 
29466                               } /*opt-block*/
29467                               
29468                               break;
29469                             case 3: 
29470                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29471                               goto MATCH_label_c512; 
29472                               
29473                               break;
29474                             default: assert(0);
29475                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29476                         break;
29477                       case 4: 
29478                         
29479                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29480                             case 0: 
29481                               
29482                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29483                                   case 0: case 1: case 2: case 3: case 6: 
29484                                   case 7: 
29485                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29486                                     goto MATCH_label_c516; 
29487                                     
29488                                     break;
29489                                   case 4: 
29490                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29491                                     if ((MATCH_w_8_16 & 0x7) 
29492                                             /* base at 16 */ == 5 && 
29493                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29494                                             /* index at 16 */ && 
29495                                       (MATCH_w_8_16 >> 3 & 0x7) 
29496                                             /* index at 16 */ < 8)) { 
29497                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
29498                                       goto MATCH_label_c518; 
29499                                       
29500                                     } /*opt-block*/
29501                                     else { 
29502                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
29503                                       goto MATCH_label_c517; 
29504                                       
29505                                     } /*opt-block*/
29506                                     
29507                                     break;
29508                                   case 5: 
29509                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
29510                                     goto MATCH_label_c519; 
29511                                     
29512                                     break;
29513                                   default: assert(0);
29514                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29515                               break;
29516                             case 1: 
29517                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29518                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29519                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29520                                       /* index at 16 */ && 
29521                                 (MATCH_w_8_16 >> 3 & 0x7) 
29522                                       /* index at 16 */ < 8)) { 
29523                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
29524                                 { 
29525                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
29526                                   int /* [~128..127] */ i8 = 
29527                                     sign_extend((MATCH_w_8_32 & 0xff) 
29528                                                       /* i8 at 32 */, 8);
29529                                   nextPC = 5 + MATCH_p; 
29530                                   
29531 #line 1567 "frontend/machine/pentium/decoder.m"
29532                                   
29533 
29534                                         // Special hack to ignore and $0xfffffff0, %esp
29535 
29536                                         Exp* oper = dis_Eaddr(Eaddr, 32);
29537 
29538                                         if (i8 != -16 || !(*oper == *Location::regOf(28)))
29539 
29540                                             stmts = instantiate(pc,  "ANDiodb", DIS_EADDR32, DIS_I8);
29541 
29542                                   
29543 
29544                                   
29545                                   
29546                                   
29547                                 }
29548                                 
29549                               } /*opt-block*/
29550                               else { 
29551                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
29552                                 goto MATCH_label_c517; 
29553                                 
29554                               } /*opt-block*/
29555                               
29556                               break;
29557                             case 2: 
29558                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29559                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29560                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29561                                       /* index at 16 */ && 
29562                                 (MATCH_w_8_16 >> 3 & 0x7) 
29563                                       /* index at 16 */ < 8)) { 
29564                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
29565                                 goto MATCH_label_c518; 
29566                                 
29567                               } /*opt-block*/
29568                               else { 
29569                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
29570                                 goto MATCH_label_c519; 
29571                                 
29572                               } /*opt-block*/
29573                               
29574                               break;
29575                             case 3: 
29576                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29577                               goto MATCH_label_c516; 
29578                               
29579                               break;
29580                             default: assert(0);
29581                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29582                         break;
29583                       case 5: 
29584                         
29585                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29586                             case 0: 
29587                               
29588                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29589                                   case 0: case 1: case 2: case 3: case 6: 
29590                                   case 7: 
29591                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29592                                     goto MATCH_label_c520; 
29593                                     
29594                                     break;
29595                                   case 4: 
29596                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29597                                     if ((MATCH_w_8_16 & 0x7) 
29598                                             /* base at 16 */ == 5 && 
29599                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29600                                             /* index at 16 */ && 
29601                                       (MATCH_w_8_16 >> 3 & 0x7) 
29602                                             /* index at 16 */ < 8)) { 
29603                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
29604                                       goto MATCH_label_c522; 
29605                                       
29606                                     } /*opt-block*/
29607                                     else { 
29608                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
29609                                       goto MATCH_label_c521; 
29610                                       
29611                                     } /*opt-block*/
29612                                     
29613                                     break;
29614                                   case 5: 
29615                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
29616                                     goto MATCH_label_c523; 
29617                                     
29618                                     break;
29619                                   default: assert(0);
29620                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29621                               break;
29622                             case 1: 
29623                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29624                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29625                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29626                                       /* index at 16 */ && 
29627                                 (MATCH_w_8_16 >> 3 & 0x7) 
29628                                       /* index at 16 */ < 8)) { 
29629                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
29630                                 { 
29631                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
29632                                   int /* [~128..127] */ i8 = 
29633                                     sign_extend((MATCH_w_8_32 & 0xff) 
29634                                                       /* i8 at 32 */, 8);
29635                                   nextPC = 5 + MATCH_p; 
29636                                   
29637 #line 1561 "frontend/machine/pentium/decoder.m"
29638                                   
29639 
29640                                         stmts = instantiate(pc,  "SUBiodb", DIS_EADDR32, DIS_I8);
29641 
29642                                   
29643 
29644                                   
29645                                   
29646                                   
29647                                 }
29648                                 
29649                               } /*opt-block*/
29650                               else { 
29651                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
29652                                 goto MATCH_label_c521; 
29653                                 
29654                               } /*opt-block*/
29655                               
29656                               break;
29657                             case 2: 
29658                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29659                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29660                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29661                                       /* index at 16 */ && 
29662                                 (MATCH_w_8_16 >> 3 & 0x7) 
29663                                       /* index at 16 */ < 8)) { 
29664                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
29665                                 goto MATCH_label_c522; 
29666                                 
29667                               } /*opt-block*/
29668                               else { 
29669                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
29670                                 goto MATCH_label_c523; 
29671                                 
29672                               } /*opt-block*/
29673                               
29674                               break;
29675                             case 3: 
29676                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29677                               goto MATCH_label_c520; 
29678                               
29679                               break;
29680                             default: assert(0);
29681                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29682                         break;
29683                       case 6: 
29684                         
29685                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29686                             case 0: 
29687                               
29688                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29689                                   case 0: case 1: case 2: case 3: case 6: 
29690                                   case 7: 
29691                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29692                                     goto MATCH_label_c524; 
29693                                     
29694                                     break;
29695                                   case 4: 
29696                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29697                                     if ((MATCH_w_8_16 & 0x7) 
29698                                             /* base at 16 */ == 5 && 
29699                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29700                                             /* index at 16 */ && 
29701                                       (MATCH_w_8_16 >> 3 & 0x7) 
29702                                             /* index at 16 */ < 8)) { 
29703                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
29704                                       goto MATCH_label_c526; 
29705                                       
29706                                     } /*opt-block*/
29707                                     else { 
29708                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
29709                                       goto MATCH_label_c525; 
29710                                       
29711                                     } /*opt-block*/
29712                                     
29713                                     break;
29714                                   case 5: 
29715                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
29716                                     goto MATCH_label_c527; 
29717                                     
29718                                     break;
29719                                   default: assert(0);
29720                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29721                               break;
29722                             case 1: 
29723                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29724                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29725                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29726                                       /* index at 16 */ && 
29727                                 (MATCH_w_8_16 >> 3 & 0x7) 
29728                                       /* index at 16 */ < 8)) { 
29729                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
29730                                 { 
29731                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
29732                                   int /* [~128..127] */ i8 = 
29733                                     sign_extend((MATCH_w_8_32 & 0xff) 
29734                                                       /* i8 at 32 */, 8);
29735                                   nextPC = 5 + MATCH_p; 
29736                                   
29737 #line 1555 "frontend/machine/pentium/decoder.m"
29738                                   
29739 
29740                                         stmts = instantiate(pc,  "XORiodb", DIS_EADDR32, DIS_I8);
29741 
29742                                   
29743 
29744                                   
29745                                   
29746                                   
29747                                 }
29748                                 
29749                               } /*opt-block*/
29750                               else { 
29751                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
29752                                 goto MATCH_label_c525; 
29753                                 
29754                               } /*opt-block*/
29755                               
29756                               break;
29757                             case 2: 
29758                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29759                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29760                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29761                                       /* index at 16 */ && 
29762                                 (MATCH_w_8_16 >> 3 & 0x7) 
29763                                       /* index at 16 */ < 8)) { 
29764                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
29765                                 goto MATCH_label_c526; 
29766                                 
29767                               } /*opt-block*/
29768                               else { 
29769                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
29770                                 goto MATCH_label_c527; 
29771                                 
29772                               } /*opt-block*/
29773                               
29774                               break;
29775                             case 3: 
29776                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29777                               goto MATCH_label_c524; 
29778                               
29779                               break;
29780                             default: assert(0);
29781                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29782                         break;
29783                       case 7: 
29784                         
29785                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29786                             case 0: 
29787                               
29788                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29789                                   case 0: case 1: case 2: case 3: case 6: 
29790                                   case 7: 
29791                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29792                                     goto MATCH_label_c528; 
29793                                     
29794                                     break;
29795                                   case 4: 
29796                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29797                                     if ((MATCH_w_8_16 & 0x7) 
29798                                             /* base at 16 */ == 5 && 
29799                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29800                                             /* index at 16 */ && 
29801                                       (MATCH_w_8_16 >> 3 & 0x7) 
29802                                             /* index at 16 */ < 8)) { 
29803                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
29804                                       goto MATCH_label_c530; 
29805                                       
29806                                     } /*opt-block*/
29807                                     else { 
29808                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
29809                                       goto MATCH_label_c529; 
29810                                       
29811                                     } /*opt-block*/
29812                                     
29813                                     break;
29814                                   case 5: 
29815                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
29816                                     goto MATCH_label_c531; 
29817                                     
29818                                     break;
29819                                   default: assert(0);
29820                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29821                               break;
29822                             case 1: 
29823                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29824                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29825                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29826                                       /* index at 16 */ && 
29827                                 (MATCH_w_8_16 >> 3 & 0x7) 
29828                                       /* index at 16 */ < 8)) { 
29829                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
29830                                 { 
29831                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
29832                                   int /* [~128..127] */ i8 = 
29833                                     sign_extend((MATCH_w_8_32 & 0xff) 
29834                                                       /* i8 at 32 */, 8);
29835                                   nextPC = 5 + MATCH_p; 
29836                                   
29837 #line 1549 "frontend/machine/pentium/decoder.m"
29838                                   
29839 
29840                                         stmts = instantiate(pc,  "CMPiodb", DIS_EADDR32, DIS_I8);
29841 
29842                                   
29843 
29844                                   
29845                                   
29846                                   
29847                                 }
29848                                 
29849                               } /*opt-block*/
29850                               else { 
29851                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
29852                                 goto MATCH_label_c529; 
29853                                 
29854                               } /*opt-block*/
29855                               
29856                               break;
29857                             case 2: 
29858                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29859                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29860                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29861                                       /* index at 16 */ && 
29862                                 (MATCH_w_8_16 >> 3 & 0x7) 
29863                                       /* index at 16 */ < 8)) { 
29864                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
29865                                 goto MATCH_label_c530; 
29866                                 
29867                               } /*opt-block*/
29868                               else { 
29869                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
29870                                 goto MATCH_label_c531; 
29871                                 
29872                               } /*opt-block*/
29873                               
29874                               break;
29875                             case 3: 
29876                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29877                               goto MATCH_label_c528; 
29878                               
29879                               break;
29880                             default: assert(0);
29881                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29882                         break;
29883                       default: assert(0);
29884                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
29885                   
29886                   break;
29887                 case 4: 
29888                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
29889                   
29890                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29891                       case 0: 
29892                         
29893                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29894                             case 0: case 1: case 2: case 3: case 6: case 7: 
29895                               goto MATCH_label_c532; break;
29896                             case 4: 
29897                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29898                               if ((MATCH_w_8_16 & 0x7) 
29899                                       /* base at 16 */ == 5 && 
29900                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29901                                       /* index at 16 */ && 
29902                                 (MATCH_w_8_16 >> 3 & 0x7) 
29903                                       /* index at 16 */ < 8)) 
29904                                 goto MATCH_label_c534;  /*opt-block+*/
29905                               else 
29906                                 goto MATCH_label_c533;  /*opt-block+*/
29907                               
29908                               break;
29909                             case 5: 
29910                               goto MATCH_label_c535; break;
29911                             default: assert(0);
29912                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29913                         break;
29914                       case 1: 
29915                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
29916                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29917                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29918                                 /* index at 16 */ && 
29919                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
29920                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
29921                           unsigned reg = 
29922                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
29923                           nextPC = 4 + MATCH_p; 
29924                           
29925 #line 384 "frontend/machine/pentium/decoder.m"
29926                           
29927 
29928                                 stmts = instantiate(pc,  "TEST.Eb.Gb", DIS_EADDR8, DIS_REG8);
29929 
29930                           
29931 
29932                           
29933                           
29934                           
29935                         } /*opt-block*//*opt-block+*/
29936                         else 
29937                           goto MATCH_label_c533;  /*opt-block+*/
29938                         
29939                         break;
29940                       case 2: 
29941                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
29942                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29943                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29944                                 /* index at 16 */ && 
29945                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
29946                           goto MATCH_label_c534;  /*opt-block+*/
29947                         else 
29948                           goto MATCH_label_c535;  /*opt-block+*/
29949                         
29950                         break;
29951                       case 3: 
29952                         goto MATCH_label_c532; break;
29953                       default: assert(0);
29954                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29955                   
29956                   break;
29957                 case 5: 
29958                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
29959                   
29960                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29961                       case 0: 
29962                         
29963                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29964                             case 0: case 1: case 2: case 3: case 6: case 7: 
29965                               goto MATCH_label_c536; break;
29966                             case 4: 
29967                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29968                               if ((MATCH_w_8_16 & 0x7) 
29969                                       /* base at 16 */ == 5 && 
29970                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29971                                       /* index at 16 */ && 
29972                                 (MATCH_w_8_16 >> 3 & 0x7) 
29973                                       /* index at 16 */ < 8)) 
29974                                 goto MATCH_label_c538;  /*opt-block+*/
29975                               else 
29976                                 goto MATCH_label_c537;  /*opt-block+*/
29977                               
29978                               break;
29979                             case 5: 
29980                               goto MATCH_label_c539; break;
29981                             default: assert(0);
29982                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29983                         break;
29984                       case 1: 
29985                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
29986                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29987                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29988                                 /* index at 16 */ && 
29989                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
29990                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
29991                           unsigned reg = 
29992                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
29993                           nextPC = 4 + MATCH_p; 
29994                           
29995 #line 378 "frontend/machine/pentium/decoder.m"
29996                           
29997 
29998                                 stmts = instantiate(pc,  "TEST.Ev.Gvod", DIS_EADDR32, DIS_REG32);
29999 
30000                           
30001 
30002                           
30003                           
30004                           
30005                         } /*opt-block*//*opt-block+*/
30006                         else 
30007                           goto MATCH_label_c537;  /*opt-block+*/
30008                         
30009                         break;
30010                       case 2: 
30011                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
30012                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30013                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30014                                 /* index at 16 */ && 
30015                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
30016                           goto MATCH_label_c538;  /*opt-block+*/
30017                         else 
30018                           goto MATCH_label_c539;  /*opt-block+*/
30019                         
30020                         break;
30021                       case 3: 
30022                         goto MATCH_label_c536; break;
30023                       default: assert(0);
30024                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30025                   
30026                   break;
30027                 case 6: 
30028                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
30029                   
30030                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30031                       case 0: 
30032                         
30033                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30034                             case 0: case 1: case 2: case 3: case 6: case 7: 
30035                               goto MATCH_label_c540; break;
30036                             case 4: 
30037                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30038                               if ((MATCH_w_8_16 & 0x7) 
30039                                       /* base at 16 */ == 5 && 
30040                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30041                                       /* index at 16 */ && 
30042                                 (MATCH_w_8_16 >> 3 & 0x7) 
30043                                       /* index at 16 */ < 8)) 
30044                                 goto MATCH_label_c542;  /*opt-block+*/
30045                               else 
30046                                 goto MATCH_label_c541;  /*opt-block+*/
30047                               
30048                               break;
30049                             case 5: 
30050                               goto MATCH_label_c543; break;
30051                             default: assert(0);
30052                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30053                         break;
30054                       case 1: 
30055                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
30056                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30057                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30058                                 /* index at 16 */ && 
30059                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
30060                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
30061                           unsigned reg = 
30062                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
30063                           nextPC = 4 + MATCH_p; 
30064                           
30065 #line 324 "frontend/machine/pentium/decoder.m"
30066                           
30067 
30068                                 stmts = instantiate(pc,  "XCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
30069 
30070                           
30071 
30072                           
30073                           
30074                           
30075                         } /*opt-block*//*opt-block+*/
30076                         else 
30077                           goto MATCH_label_c541;  /*opt-block+*/
30078                         
30079                         break;
30080                       case 2: 
30081                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
30082                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30083                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30084                                 /* index at 16 */ && 
30085                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
30086                           goto MATCH_label_c542;  /*opt-block+*/
30087                         else 
30088                           goto MATCH_label_c543;  /*opt-block+*/
30089                         
30090                         break;
30091                       case 3: 
30092                         goto MATCH_label_c540; break;
30093                       default: assert(0);
30094                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30095                   
30096                   break;
30097                 case 7: 
30098                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
30099                   
30100                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30101                       case 0: 
30102                         
30103                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30104                             case 0: case 1: case 2: case 3: case 6: case 7: 
30105                               goto MATCH_label_c544; break;
30106                             case 4: 
30107                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30108                               if ((MATCH_w_8_16 & 0x7) 
30109                                       /* base at 16 */ == 5 && 
30110                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30111                                       /* index at 16 */ && 
30112                                 (MATCH_w_8_16 >> 3 & 0x7) 
30113                                       /* index at 16 */ < 8)) 
30114                                 goto MATCH_label_c546;  /*opt-block+*/
30115                               else 
30116                                 goto MATCH_label_c545;  /*opt-block+*/
30117                               
30118                               break;
30119                             case 5: 
30120                               goto MATCH_label_c547; break;
30121                             default: assert(0);
30122                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30123                         break;
30124                       case 1: 
30125                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
30126                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30127                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30128                                 /* index at 16 */ && 
30129                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
30130                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
30131                           unsigned reg = 
30132                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
30133                           nextPC = 4 + MATCH_p; 
30134                           
30135 #line 318 "frontend/machine/pentium/decoder.m"
30136                           
30137 
30138                                 stmts = instantiate(pc,  "XCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
30139 
30140                           
30141 
30142                           
30143                           
30144                           
30145                         } /*opt-block*//*opt-block+*/
30146                         else 
30147                           goto MATCH_label_c545;  /*opt-block+*/
30148                         
30149                         break;
30150                       case 2: 
30151                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
30152                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30153                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30154                                 /* index at 16 */ && 
30155                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
30156                           goto MATCH_label_c546;  /*opt-block+*/
30157                         else 
30158                           goto MATCH_label_c547;  /*opt-block+*/
30159                         
30160                         break;
30161                       case 3: 
30162                         goto MATCH_label_c544; break;
30163                       default: assert(0);
30164                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30165                   
30166                   break;
30167                 default: assert(0);
30168               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
30169             break;
30170           case 9: 
30171             if ((MATCH_w_8_0 & 0x7) /* col at 0 */ == 0) { 
30172               nextPC = 1 + MATCH_p; 
30173               
30174 #line 327 "frontend/machine/pentium/decoder.m"
30175               
30176 
30177                     stmts = instantiate(pc,  "NOP");
30178 
30179               
30180 
30181               
30182               
30183               
30184             } /*opt-block*//*opt-block+*/
30185             else { 
30186               unsigned r32 = (MATCH_w_8_0 & 0x7) /* r32 at 0 */;
30187               nextPC = 1 + MATCH_p; 
30188               
30189 #line 348 "frontend/machine/pentium/decoder.m"
30190               
30191 
30192                     stmts = instantiate(pc,  "XCHGeAXod", DIS_R32);
30193 
30194               
30195 
30196               
30197               
30198               
30199             } /*opt-block*//*opt-block+*/
30200             
30201             break;
30202           case 10: 
30203             
30204               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
30205                 case 0: 
30206                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
30207                   { 
30208                     unsigned off = MATCH_w_32_8 /* i32 at 8 */;
30209                     nextPC = 5 + MATCH_p; 
30210                     
30211 #line 1013 "frontend/machine/pentium/decoder.m"
30212                     
30213 
30214                             stmts = instantiate(pc,  "MOV.AL.Ob", DIS_OFF);
30215 
30216                     
30217 
30218                     //    | MOV.Sw.Ew(Mem, sr16) =>
30219 
30220                     //        stmts = instantiate(pc,  "MOV.Sw.Ew", DIS_MEM, DIS_SR16);
30221 
30222                     
30223 
30224                     //    | MOV.Ew.Sw(Mem, sr16) =>
30225 
30226                     //        stmts = instantiate(pc,  "MOV.Ew.Sw", DIS_MEM, DIS_SR16);
30227 
30228                     
30229 
30230                     
30231                     
30232                     
30233                   }
30234                   
30235                   break;
30236                 case 1: 
30237                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
30238                   { 
30239                     unsigned off = MATCH_w_32_8 /* i32 at 8 */;
30240                     nextPC = 5 + MATCH_p; 
30241                     
30242 #line 1007 "frontend/machine/pentium/decoder.m"
30243                     
30244 
30245                             stmts = instantiate(pc,  "MOV.eAX.Ovod", DIS_OFF);
30246 
30247                     
30248 
30249                     
30250                     
30251                     
30252                   }
30253                   
30254                   break;
30255                 case 2: 
30256                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
30257                   { 
30258                     unsigned off = MATCH_w_32_8 /* i32 at 8 */;
30259                     nextPC = 5 + MATCH_p; 
30260                     
30261 #line 1004 "frontend/machine/pentium/decoder.m"
30262                     
30263 
30264                             stmts = instantiate(pc,  "MOV.Ob.AL", DIS_OFF);
30265 
30266                     
30267 
30268                     
30269                     
30270                     
30271                   }
30272                   
30273                   break;
30274                 case 3: 
30275                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
30276                   { 
30277                     unsigned off = MATCH_w_32_8 /* i32 at 8 */;
30278                     nextPC = 5 + MATCH_p; 
30279                     
30280 #line 998 "frontend/machine/pentium/decoder.m"
30281                     
30282 
30283                             stmts = instantiate(pc,  "MOV.Ov.eAXod", DIS_OFF);
30284 
30285                     
30286 
30287                     
30288                     
30289                     
30290                   }
30291                   
30292                   break;
30293                 case 4: 
30294                   nextPC = 1 + MATCH_p; 
30295                   
30296 #line 961 "frontend/machine/pentium/decoder.m"
30297                   
30298 
30299                         stmts = instantiate(pc,  "MOVSB");
30300 
30301                   
30302 
30303                   //      | MOV.Rd.Dd(reg, dr) => 
30304 
30305                   //          unused(reg); unused(dr);
30306 
30307                   //          stmts = instantiate(pc,  "UNIMP");
30308 
30309                   
30310 
30311                   //      | MOV.Dd.Rd(dr, reg) =>
30312 
30313                   //          unused(reg); unused(dr);
30314 
30315                   //          stmts = instantiate(pc,  "UNIMP");
30316 
30317                   
30318 
30319                   //      | MOV.Rd.Cd(reg, cr) =>
30320 
30321                   //          unused(reg); unused(cr);
30322 
30323                   //          stmts = instantiate(pc,  "UNIMP");
30324 
30325                   
30326 
30327                   //      | MOV.Cd.Rd(cr, reg) =>
30328 
30329                   //          unused(reg); unused(cr);
30330 
30331                   //          stmts = instantiate(pc,  "UNIMP");
30332 
30333                   
30334 
30335                   
30336                   
30337                   
30338                   
30339                   break;
30340                 case 5: 
30341                   nextPC = 1 + MATCH_p; 
30342                   
30343 #line 955 "frontend/machine/pentium/decoder.m"
30344                   
30345 
30346                         stmts = instantiate(pc,  "MOVSvod");
30347 
30348                   
30349 
30350                   
30351                   
30352                   
30353                   
30354                   break;
30355                 case 6: 
30356                   nextPC = 1 + MATCH_p; 
30357                   
30358 #line 1253 "frontend/machine/pentium/decoder.m"
30359                   
30360 
30361                         stmts = instantiate(pc,  "CMPSB");
30362 
30363                   
30364 
30365                   
30366                   
30367                   
30368                   
30369                   break;
30370                 case 7: 
30371                   nextPC = 1 + MATCH_p; 
30372                   
30373 #line 1247 "frontend/machine/pentium/decoder.m"
30374                   
30375 
30376                         stmts = instantiate(pc,  "CMPSvod");
30377 
30378                   
30379 
30380                   
30381                   
30382                   
30383                   
30384                   break;
30385                 default: assert(0);
30386               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
30387             break;
30388           case 11: 
30389             MATCH_w_8_8 = getByte(1 + MATCH_p); 
30390             { 
30391               int /* [~128..127] */ i8 = 
30392                 sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
30393               unsigned r8 = (MATCH_w_8_0 & 0x7) /* r8 at 0 */;
30394               nextPC = 2 + MATCH_p; 
30395               
30396 #line 995 "frontend/machine/pentium/decoder.m"
30397               
30398 
30399                     stmts = instantiate(pc,  "MOVib", DIS_R8, DIS_I8);
30400 
30401               
30402 
30403               
30404               
30405               
30406             }
30407             
30408             break;
30409           case 12: 
30410             
30411               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
30412                 case 0: 
30413                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
30414                   
30415                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
30416                       case 0: 
30417                         
30418                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30419                             case 0: 
30420                               
30421                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30422                                   case 0: case 1: case 2: case 3: case 6: 
30423                                   case 7: 
30424                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30425                                     goto MATCH_label_c548; 
30426                                     
30427                                     break;
30428                                   case 4: 
30429                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30430                                     if ((MATCH_w_8_16 & 0x7) 
30431                                             /* base at 16 */ == 5 && 
30432                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30433                                             /* index at 16 */ && 
30434                                       (MATCH_w_8_16 >> 3 & 0x7) 
30435                                             /* index at 16 */ < 8)) { 
30436                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
30437                                       goto MATCH_label_c550; 
30438                                       
30439                                     } /*opt-block*/
30440                                     else { 
30441                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
30442                                       goto MATCH_label_c549; 
30443                                       
30444                                     } /*opt-block*/
30445                                     
30446                                     break;
30447                                   case 5: 
30448                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
30449                                     goto MATCH_label_c551; 
30450                                     
30451                                     break;
30452                                   default: assert(0);
30453                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30454                               break;
30455                             case 1: 
30456                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30457                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30458                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30459                                       /* index at 16 */ && 
30460                                 (MATCH_w_8_16 >> 3 & 0x7) 
30461                                       /* index at 16 */ < 8)) { 
30462                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
30463                                 { 
30464                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
30465                                   int /* [~128..127] */ i8 = 
30466                                     sign_extend((MATCH_w_8_32 & 0xff) 
30467                                                       /* i8 at 32 */, 8);
30468                                   nextPC = 5 + MATCH_p; 
30469                                   
30470 #line 659 "frontend/machine/pentium/decoder.m"
30471                                   
30472 
30473                                         stmts = instantiate(pc,  "ROLB.Eb.Ib", DIS_EADDR8, DIS_I8);
30474 
30475                                   
30476 
30477                                   
30478                                   
30479                                   
30480                                 }
30481                                 
30482                               } /*opt-block*/
30483                               else { 
30484                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
30485                                 goto MATCH_label_c549; 
30486                                 
30487                               } /*opt-block*/
30488                               
30489                               break;
30490                             case 2: 
30491                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30492                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30493                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30494                                       /* index at 16 */ && 
30495                                 (MATCH_w_8_16 >> 3 & 0x7) 
30496                                       /* index at 16 */ < 8)) { 
30497                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
30498                                 goto MATCH_label_c550; 
30499                                 
30500                               } /*opt-block*/
30501                               else { 
30502                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
30503                                 goto MATCH_label_c551; 
30504                                 
30505                               } /*opt-block*/
30506                               
30507                               break;
30508                             case 3: 
30509                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30510                               goto MATCH_label_c548; 
30511                               
30512                               break;
30513                             default: assert(0);
30514                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30515                         break;
30516                       case 1: 
30517                         
30518                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30519                             case 0: 
30520                               
30521                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30522                                   case 0: case 1: case 2: case 3: case 6: 
30523                                   case 7: 
30524                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30525                                     goto MATCH_label_c552; 
30526                                     
30527                                     break;
30528                                   case 4: 
30529                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30530                                     if ((MATCH_w_8_16 & 0x7) 
30531                                             /* base at 16 */ == 5 && 
30532                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30533                                             /* index at 16 */ && 
30534                                       (MATCH_w_8_16 >> 3 & 0x7) 
30535                                             /* index at 16 */ < 8)) { 
30536                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
30537                                       goto MATCH_label_c554; 
30538                                       
30539                                     } /*opt-block*/
30540                                     else { 
30541                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
30542                                       goto MATCH_label_c553; 
30543                                       
30544                                     } /*opt-block*/
30545                                     
30546                                     break;
30547                                   case 5: 
30548                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
30549                                     goto MATCH_label_c555; 
30550                                     
30551                                     break;
30552                                   default: assert(0);
30553                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30554                               break;
30555                             case 1: 
30556                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30557                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30558                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30559                                       /* index at 16 */ && 
30560                                 (MATCH_w_8_16 >> 3 & 0x7) 
30561                                       /* index at 16 */ < 8)) { 
30562                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
30563                                 { 
30564                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
30565                                   int /* [~128..127] */ i8 = 
30566                                     sign_extend((MATCH_w_8_32 & 0xff) 
30567                                                       /* i8 at 32 */, 8);
30568                                   nextPC = 5 + MATCH_p; 
30569                                   
30570 #line 656 "frontend/machine/pentium/decoder.m"
30571                                   
30572 
30573                                         stmts = instantiate(pc,  "RORB.Eb.Ib", DIS_EADDR8, DIS_I8);
30574 
30575                                   
30576 
30577                                   
30578                                   
30579                                   
30580                                 }
30581                                 
30582                               } /*opt-block*/
30583                               else { 
30584                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
30585                                 goto MATCH_label_c553; 
30586                                 
30587                               } /*opt-block*/
30588                               
30589                               break;
30590                             case 2: 
30591                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30592                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30593                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30594                                       /* index at 16 */ && 
30595                                 (MATCH_w_8_16 >> 3 & 0x7) 
30596                                       /* index at 16 */ < 8)) { 
30597                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
30598                                 goto MATCH_label_c554; 
30599                                 
30600                               } /*opt-block*/
30601                               else { 
30602                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
30603                                 goto MATCH_label_c555; 
30604                                 
30605                               } /*opt-block*/
30606                               
30607                               break;
30608                             case 3: 
30609                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30610                               goto MATCH_label_c552; 
30611                               
30612                               break;
30613                             default: assert(0);
30614                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30615                         break;
30616                       case 2: 
30617                         
30618                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30619                             case 0: 
30620                               
30621                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30622                                   case 0: case 1: case 2: case 3: case 6: 
30623                                   case 7: 
30624                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30625                                     goto MATCH_label_c556; 
30626                                     
30627                                     break;
30628                                   case 4: 
30629                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30630                                     if ((MATCH_w_8_16 & 0x7) 
30631                                             /* base at 16 */ == 5 && 
30632                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30633                                             /* index at 16 */ && 
30634                                       (MATCH_w_8_16 >> 3 & 0x7) 
30635                                             /* index at 16 */ < 8)) { 
30636                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
30637                                       goto MATCH_label_c558; 
30638                                       
30639                                     } /*opt-block*/
30640                                     else { 
30641                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
30642                                       goto MATCH_label_c557; 
30643                                       
30644                                     } /*opt-block*/
30645                                     
30646                                     break;
30647                                   case 5: 
30648                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
30649                                     goto MATCH_label_c559; 
30650                                     
30651                                     break;
30652                                   default: assert(0);
30653                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30654                               break;
30655                             case 1: 
30656                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30657                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30658                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30659                                       /* index at 16 */ && 
30660                                 (MATCH_w_8_16 >> 3 & 0x7) 
30661                                       /* index at 16 */ < 8)) { 
30662                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
30663                                 { 
30664                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
30665                                   int /* [~128..127] */ i8 = 
30666                                     sign_extend((MATCH_w_8_32 & 0xff) 
30667                                                       /* i8 at 32 */, 8);
30668                                   nextPC = 5 + MATCH_p; 
30669                                   
30670 #line 653 "frontend/machine/pentium/decoder.m"
30671                                   
30672 
30673                                         stmts = instantiate(pc,  "RCLB.Eb.Ib", DIS_EADDR8, DIS_I8);
30674 
30675                                   
30676 
30677                                   
30678                                   
30679                                   
30680                                 }
30681                                 
30682                               } /*opt-block*/
30683                               else { 
30684                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
30685                                 goto MATCH_label_c557; 
30686                                 
30687                               } /*opt-block*/
30688                               
30689                               break;
30690                             case 2: 
30691                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30692                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30693                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30694                                       /* index at 16 */ && 
30695                                 (MATCH_w_8_16 >> 3 & 0x7) 
30696                                       /* index at 16 */ < 8)) { 
30697                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
30698                                 goto MATCH_label_c558; 
30699                                 
30700                               } /*opt-block*/
30701                               else { 
30702                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
30703                                 goto MATCH_label_c559; 
30704                                 
30705                               } /*opt-block*/
30706                               
30707                               break;
30708                             case 3: 
30709                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30710                               goto MATCH_label_c556; 
30711                               
30712                               break;
30713                             default: assert(0);
30714                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30715                         break;
30716                       case 3: 
30717                         
30718                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30719                             case 0: 
30720                               
30721                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30722                                   case 0: case 1: case 2: case 3: case 6: 
30723                                   case 7: 
30724                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30725                                     goto MATCH_label_c560; 
30726                                     
30727                                     break;
30728                                   case 4: 
30729                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30730                                     if ((MATCH_w_8_16 & 0x7) 
30731                                             /* base at 16 */ == 5 && 
30732                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30733                                             /* index at 16 */ && 
30734                                       (MATCH_w_8_16 >> 3 & 0x7) 
30735                                             /* index at 16 */ < 8)) { 
30736                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
30737                                       goto MATCH_label_c562; 
30738                                       
30739                                     } /*opt-block*/
30740                                     else { 
30741                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
30742                                       goto MATCH_label_c561; 
30743                                       
30744                                     } /*opt-block*/
30745                                     
30746                                     break;
30747                                   case 5: 
30748                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
30749                                     goto MATCH_label_c563; 
30750                                     
30751                                     break;
30752                                   default: assert(0);
30753                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30754                               break;
30755                             case 1: 
30756                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30757                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30758                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30759                                       /* index at 16 */ && 
30760                                 (MATCH_w_8_16 >> 3 & 0x7) 
30761                                       /* index at 16 */ < 8)) { 
30762                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
30763                                 { 
30764                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
30765                                   int /* [~128..127] */ i8 = 
30766                                     sign_extend((MATCH_w_8_32 & 0xff) 
30767                                                       /* i8 at 32 */, 8);
30768                                   nextPC = 5 + MATCH_p; 
30769                                   
30770 #line 650 "frontend/machine/pentium/decoder.m"
30771                                   
30772 
30773                                         stmts = instantiate(pc,  "RCRB.Eb.Ib", DIS_EADDR8, DIS_I8);
30774 
30775                                   
30776 
30777                                   
30778                                   
30779                                   
30780                                 }
30781                                 
30782                               } /*opt-block*/
30783                               else { 
30784                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
30785                                 goto MATCH_label_c561; 
30786                                 
30787                               } /*opt-block*/
30788                               
30789                               break;
30790                             case 2: 
30791                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30792                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30793                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30794                                       /* index at 16 */ && 
30795                                 (MATCH_w_8_16 >> 3 & 0x7) 
30796                                       /* index at 16 */ < 8)) { 
30797                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
30798                                 goto MATCH_label_c562; 
30799                                 
30800                               } /*opt-block*/
30801                               else { 
30802                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
30803                                 goto MATCH_label_c563; 
30804                                 
30805                               } /*opt-block*/
30806                               
30807                               break;
30808                             case 3: 
30809                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30810                               goto MATCH_label_c560; 
30811                               
30812                               break;
30813                             default: assert(0);
30814                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30815                         break;
30816                       case 4: 
30817                         
30818                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30819                             case 0: 
30820                               
30821                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30822                                   case 0: case 1: case 2: case 3: case 6: 
30823                                   case 7: 
30824                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30825                                     goto MATCH_label_c564; 
30826                                     
30827                                     break;
30828                                   case 4: 
30829                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30830                                     if ((MATCH_w_8_16 & 0x7) 
30831                                             /* base at 16 */ == 5 && 
30832                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30833                                             /* index at 16 */ && 
30834                                       (MATCH_w_8_16 >> 3 & 0x7) 
30835                                             /* index at 16 */ < 8)) { 
30836                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
30837                                       goto MATCH_label_c566; 
30838                                       
30839                                     } /*opt-block*/
30840                                     else { 
30841                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
30842                                       goto MATCH_label_c565; 
30843                                       
30844                                     } /*opt-block*/
30845                                     
30846                                     break;
30847                                   case 5: 
30848                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
30849                                     goto MATCH_label_c567; 
30850                                     
30851                                     break;
30852                                   default: assert(0);
30853                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30854                               break;
30855                             case 1: 
30856                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30857                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30858                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30859                                       /* index at 16 */ && 
30860                                 (MATCH_w_8_16 >> 3 & 0x7) 
30861                                       /* index at 16 */ < 8)) { 
30862                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
30863                                 { 
30864                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
30865                                   int /* [~128..127] */ i8 = 
30866                                     sign_extend((MATCH_w_8_32 & 0xff) 
30867                                                       /* i8 at 32 */, 8);
30868                                   nextPC = 5 + MATCH_p; 
30869                                   
30870 #line 647 "frontend/machine/pentium/decoder.m"
30871                                   
30872 
30873                                         stmts = instantiate(pc,  "SHLSALB.Eb.Ib", DIS_EADDR8, DIS_I8);
30874 
30875                                   
30876 
30877                                   
30878                                   
30879                                   
30880                                 }
30881                                 
30882                               } /*opt-block*/
30883                               else { 
30884                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
30885                                 goto MATCH_label_c565; 
30886                                 
30887                               } /*opt-block*/
30888                               
30889                               break;
30890                             case 2: 
30891                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30892                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30893                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30894                                       /* index at 16 */ && 
30895                                 (MATCH_w_8_16 >> 3 & 0x7) 
30896                                       /* index at 16 */ < 8)) { 
30897                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
30898                                 goto MATCH_label_c566; 
30899                                 
30900                               } /*opt-block*/
30901                               else { 
30902                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
30903                                 goto MATCH_label_c567; 
30904                                 
30905                               } /*opt-block*/
30906                               
30907                               break;
30908                             case 3: 
30909                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30910                               goto MATCH_label_c564; 
30911                               
30912                               break;
30913                             default: assert(0);
30914                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30915                         break;
30916                       case 5: 
30917                         
30918                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30919                             case 0: 
30920                               
30921                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30922                                   case 0: case 1: case 2: case 3: case 6: 
30923                                   case 7: 
30924                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30925                                     goto MATCH_label_c568; 
30926                                     
30927                                     break;
30928                                   case 4: 
30929                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30930                                     if ((MATCH_w_8_16 & 0x7) 
30931                                             /* base at 16 */ == 5 && 
30932                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30933                                             /* index at 16 */ && 
30934                                       (MATCH_w_8_16 >> 3 & 0x7) 
30935                                             /* index at 16 */ < 8)) { 
30936                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
30937                                       goto MATCH_label_c570; 
30938                                       
30939                                     } /*opt-block*/
30940                                     else { 
30941                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
30942                                       goto MATCH_label_c569; 
30943                                       
30944                                     } /*opt-block*/
30945                                     
30946                                     break;
30947                                   case 5: 
30948                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
30949                                     goto MATCH_label_c571; 
30950                                     
30951                                     break;
30952                                   default: assert(0);
30953                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30954                               break;
30955                             case 1: 
30956                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30957                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30958                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30959                                       /* index at 16 */ && 
30960                                 (MATCH_w_8_16 >> 3 & 0x7) 
30961                                       /* index at 16 */ < 8)) { 
30962                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
30963                                 { 
30964                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
30965                                   int /* [~128..127] */ i8 = 
30966                                     sign_extend((MATCH_w_8_32 & 0xff) 
30967                                                       /* i8 at 32 */, 8);
30968                                   nextPC = 5 + MATCH_p; 
30969                                   
30970 #line 644 "frontend/machine/pentium/decoder.m"
30971                                   
30972 
30973                                         stmts = instantiate(pc,  "SHRB.Eb.Ib", DIS_EADDR8, DIS_I8);
30974 
30975                                   
30976 
30977                                   
30978                                   
30979                                   
30980                                 }
30981                                 
30982                               } /*opt-block*/
30983                               else { 
30984                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
30985                                 goto MATCH_label_c569; 
30986                                 
30987                               } /*opt-block*/
30988                               
30989                               break;
30990                             case 2: 
30991                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30992                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30993                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30994                                       /* index at 16 */ && 
30995                                 (MATCH_w_8_16 >> 3 & 0x7) 
30996                                       /* index at 16 */ < 8)) { 
30997                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
30998                                 goto MATCH_label_c570; 
30999                                 
31000                               } /*opt-block*/
31001                               else { 
31002                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
31003                                 goto MATCH_label_c571; 
31004                                 
31005                               } /*opt-block*/
31006                               
31007                               break;
31008                             case 3: 
31009                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31010                               goto MATCH_label_c568; 
31011                               
31012                               break;
31013                             default: assert(0);
31014                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
31015                         break;
31016                       case 6: 
31017                         goto MATCH_label_c64; break;
31018                       case 7: 
31019                         
31020                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
31021                             case 0: 
31022                               
31023                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
31024                                   case 0: case 1: case 2: case 3: case 6: 
31025                                   case 7: 
31026                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31027                                     goto MATCH_label_c572; 
31028                                     
31029                                     break;
31030                                   case 4: 
31031                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31032                                     if ((MATCH_w_8_16 & 0x7) 
31033                                             /* base at 16 */ == 5 && 
31034                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31035                                             /* index at 16 */ && 
31036                                       (MATCH_w_8_16 >> 3 & 0x7) 
31037                                             /* index at 16 */ < 8)) { 
31038                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
31039                                       goto MATCH_label_c574; 
31040                                       
31041                                     } /*opt-block*/
31042                                     else { 
31043                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
31044                                       goto MATCH_label_c573; 
31045                                       
31046                                     } /*opt-block*/
31047                                     
31048                                     break;
31049                                   case 5: 
31050                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
31051                                     goto MATCH_label_c575; 
31052                                     
31053                                     break;
31054                                   default: assert(0);
31055                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
31056                               break;
31057                             case 1: 
31058                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31059                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31060                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31061                                       /* index at 16 */ && 
31062                                 (MATCH_w_8_16 >> 3 & 0x7) 
31063                                       /* index at 16 */ < 8)) { 
31064                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
31065                                 { 
31066                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
31067                                   int /* [~128..127] */ i8 = 
31068                                     sign_extend((MATCH_w_8_32 & 0xff) 
31069                                                       /* i8 at 32 */, 8);
31070                                   nextPC = 5 + MATCH_p; 
31071                                   
31072 #line 641 "frontend/machine/pentium/decoder.m"
31073                                   
31074 
31075                                         stmts = instantiate(pc,  "SARB.Eb.Ib", DIS_EADDR8, DIS_I8);
31076 
31077                                   
31078 
31079                                   
31080                                   
31081                                   
31082                                 }
31083                                 
31084                               } /*opt-block*/
31085                               else { 
31086                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
31087                                 goto MATCH_label_c573; 
31088                                 
31089                               } /*opt-block*/
31090                               
31091                               break;
31092                             case 2: 
31093                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31094                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31095                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31096                                       /* index at 16 */ && 
31097                                 (MATCH_w_8_16 >> 3 & 0x7) 
31098                                       /* index at 16 */ < 8)) { 
31099                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
31100                                 goto MATCH_label_c574; 
31101                                 
31102                               } /*opt-block*/
31103                               else { 
31104                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
31105                                 goto MATCH_label_c575; 
31106                                 
31107                               } /*opt-block*/
31108                               
31109                               break;
31110                             case 3: 
31111                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31112                               goto MATCH_label_c572; 
31113                               
31114                               break;
31115                             default: assert(0);
31116                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
31117                         break;
31118                       default: assert(0);
31119                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
31120                   
31121                   break;
31122                 case 1: 
31123                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
31124                   
31125                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
31126                       case 0: 
31127                         
31128                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
31129                             case 0: 
31130                               
31131                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
31132                                   case 0: case 1: case 2: case 3: case 6: 
31133                                   case 7: 
31134                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31135                                     goto MATCH_label_c576; 
31136                                     
31137                                     break;
31138                                   case 4: 
31139                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31140                                     if ((MATCH_w_8_16 & 0x7) 
31141                                             /* base at 16 */ == 5 && 
31142                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31143                                             /* index at 16 */ && 
31144                                       (MATCH_w_8_16 >> 3 & 0x7) 
31145                                             /* index at 16 */ < 8)) { 
31146                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
31147                                       goto MATCH_label_c578; 
31148                                       
31149                                     } /*opt-block*/
31150                                     else { 
31151                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
31152                                       goto MATCH_label_c577; 
31153                                       
31154                                     } /*opt-block*/
31155                                     
31156                                     break;
31157                                   case 5: 
31158                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
31159                                     goto MATCH_label_c579; 
31160                                     
31161                                     break;
31162                                   default: assert(0);
31163                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
31164                               break;
31165                             case 1: 
31166                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31167                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31168                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31169                                       /* index at 16 */ && 
31170                                 (MATCH_w_8_16 >> 3 & 0x7) 
31171                                       /* index at 16 */ < 8)) { 
31172                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
31173                                 { 
31174                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
31175                                   int /* [~128..127] */ i8 = 
31176                                     sign_extend((MATCH_w_8_32 & 0xff) 
31177                                                       /* i8 at 32 */, 8);
31178                                   nextPC = 5 + MATCH_p; 
31179                                   
31180 #line 635 "frontend/machine/pentium/decoder.m"
31181                                   
31182 
31183                                         stmts = instantiate(pc,  "ROLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
31184 
31185                                   
31186 
31187                                   
31188                                   
31189                                   
31190                                 }
31191                                 
31192                               } /*opt-block*/
31193                               else { 
31194                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
31195                                 goto MATCH_label_c577; 
31196                                 
31197                               } /*opt-block*/
31198                               
31199                               break;
31200                             case 2: 
31201                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31202                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31203                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31204                                       /* index at 16 */ && 
31205                                 (MATCH_w_8_16 >> 3 & 0x7) 
31206                                       /* index at 16 */ < 8)) { 
31207                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
31208                                 goto MATCH_label_c578; 
31209                                 
31210                               } /*opt-block*/
31211                               else { 
31212                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
31213                                 goto MATCH_label_c579; 
31214                                 
31215                               } /*opt-block*/
31216                               
31217                               break;
31218                             case 3: 
31219                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31220                               goto MATCH_label_c576; 
31221                               
31222                               break;
31223                             default: assert(0);
31224                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
31225                         break;
31226                       case 1: 
31227                         
31228                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
31229                             case 0: 
31230                               
31231                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
31232                                   case 0: case 1: case 2: case 3: case 6: 
31233                                   case 7: 
31234                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31235                                     goto MATCH_label_c580; 
31236                                     
31237                                     break;
31238                                   case 4: 
31239                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31240                                     if ((MATCH_w_8_16 & 0x7) 
31241                                             /* base at 16 */ == 5 && 
31242                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31243                                             /* index at 16 */ && 
31244                                       (MATCH_w_8_16 >> 3 & 0x7) 
31245                                             /* index at 16 */ < 8)) { 
31246                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
31247                                       goto MATCH_label_c582; 
31248                                       
31249                                     } /*opt-block*/
31250                                     else { 
31251                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
31252                                       goto MATCH_label_c581; 
31253                                       
31254                                     } /*opt-block*/
31255                                     
31256                                     break;
31257                                   case 5: 
31258                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
31259                                     goto MATCH_label_c583; 
31260                                     
31261                                     break;
31262                                   default: assert(0);
31263                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
31264                               break;
31265                             case 1: 
31266                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31267                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31268                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31269                                       /* index at 16 */ && 
31270                                 (MATCH_w_8_16 >> 3 & 0x7) 
31271                                       /* index at 16 */ < 8)) { 
31272                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
31273                                 { 
31274                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
31275                                   int /* [~128..127] */ i8 = 
31276                                     sign_extend((MATCH_w_8_32 & 0xff) 
31277                                                       /* i8 at 32 */, 8);
31278                                   nextPC = 5 + MATCH_p; 
31279                                   
31280 #line 629 "frontend/machine/pentium/decoder.m"
31281                                   
31282 
31283                                         stmts = instantiate(pc,  "RORB.Ev.Ibod", DIS_EADDR32, DIS_I8);
31284 
31285                                   
31286 
31287                                   
31288                                   
31289                                   
31290                                 }
31291                                 
31292                               } /*opt-block*/
31293                               else { 
31294                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
31295                                 goto MATCH_label_c581; 
31296                                 
31297                               } /*opt-block*/
31298                               
31299                               break;
31300                             case 2: 
31301                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31302                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31303                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31304                                       /* index at 16 */ && 
31305                                 (MATCH_w_8_16 >> 3 & 0x7) 
31306                                       /* index at 16 */ < 8)) { 
31307                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
31308                                 goto MATCH_label_c582; 
31309                                 
31310                               } /*opt-block*/
31311                               else { 
31312                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
31313                                 goto MATCH_label_c583; 
31314                                 
31315                               } /*opt-block*/
31316                               
31317                               break;
31318                             case 3: 
31319                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31320                               goto MATCH_label_c580; 
31321                               
31322                               break;
31323                             default: assert(0);
31324                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
31325                         break;
31326                       case 2: 
31327                         
31328                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
31329                             case 0: 
31330                               
31331                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
31332                                   case 0: case 1: case 2: case 3: case 6: 
31333                                   case 7: 
31334                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31335                                     goto MATCH_label_c584; 
31336                                     
31337                                     break;
31338                                   case 4: 
31339                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31340                                     if ((MATCH_w_8_16 & 0x7) 
31341                                             /* base at 16 */ == 5 && 
31342                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31343                                             /* index at 16 */ && 
31344                                       (MATCH_w_8_16 >> 3 & 0x7) 
31345                                             /* index at 16 */ < 8)) { 
31346                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
31347                                       goto MATCH_label_c586; 
31348                                       
31349                                     } /*opt-block*/
31350                                     else { 
31351                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
31352                                       goto MATCH_label_c585; 
31353                                       
31354                                     } /*opt-block*/
31355                                     
31356                                     break;
31357                                   case 5: 
31358                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
31359                                     goto MATCH_label_c587; 
31360                                     
31361                                     break;
31362                                   default: assert(0);
31363                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
31364                               break;
31365                             case 1: 
31366                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31367                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31368                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31369                                       /* index at 16 */ && 
31370                                 (MATCH_w_8_16 >> 3 & 0x7) 
31371                                       /* index at 16 */ < 8)) { 
31372                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
31373                                 { 
31374                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
31375                                   int /* [~128..127] */ i8 = 
31376                                     sign_extend((MATCH_w_8_32 & 0xff) 
31377                                                       /* i8 at 32 */, 8);
31378                                   nextPC = 5 + MATCH_p; 
31379                                   
31380 #line 623 "frontend/machine/pentium/decoder.m"
31381                                   
31382 
31383                                         stmts = instantiate(pc,  "RCLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
31384 
31385                                   
31386 
31387                                   
31388                                   
31389                                   
31390                                 }
31391                                 
31392                               } /*opt-block*/
31393                               else { 
31394                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
31395                                 goto MATCH_label_c585; 
31396                                 
31397                               } /*opt-block*/
31398                               
31399                               break;
31400                             case 2: 
31401                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31402                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31403                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31404                                       /* index at 16 */ && 
31405                                 (MATCH_w_8_16 >> 3 & 0x7) 
31406                                       /* index at 16 */ < 8)) { 
31407                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
31408                                 goto MATCH_label_c586; 
31409                                 
31410                               } /*opt-block*/
31411                               else { 
31412                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
31413                                 goto MATCH_label_c587; 
31414                                 
31415                               } /*opt-block*/
31416                               
31417                               break;
31418                             case 3: 
31419                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31420                               goto MATCH_label_c584; 
31421                               
31422                               break;
31423                             default: assert(0);
31424                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
31425                         break;
31426                       case 3: 
31427                         
31428                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
31429                             case 0: 
31430                               
31431                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
31432                                   case 0: case 1: case 2: case 3: case 6: 
31433                                   case 7: 
31434                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31435                                     goto MATCH_label_c588; 
31436                                     
31437                                     break;
31438                                   case 4: 
31439                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31440                                     if ((MATCH_w_8_16 & 0x7) 
31441                                             /* base at 16 */ == 5 && 
31442                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31443                                             /* index at 16 */ && 
31444                                       (MATCH_w_8_16 >> 3 & 0x7) 
31445                                             /* index at 16 */ < 8)) { 
31446                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
31447                                       goto MATCH_label_c590; 
31448                                       
31449                                     } /*opt-block*/
31450                                     else { 
31451                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
31452                                       goto MATCH_label_c589; 
31453                                       
31454                                     } /*opt-block*/
31455                                     
31456                                     break;
31457                                   case 5: 
31458                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
31459                                     goto MATCH_label_c591; 
31460                                     
31461                                     break;
31462                                   default: assert(0);
31463                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
31464                               break;
31465                             case 1: 
31466                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31467                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31468                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31469                                       /* index at 16 */ && 
31470                                 (MATCH_w_8_16 >> 3 & 0x7) 
31471                                       /* index at 16 */ < 8)) { 
31472                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
31473                                 { 
31474                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
31475                                   int /* [~128..127] */ i8 = 
31476                                     sign_extend((MATCH_w_8_32 & 0xff) 
31477                                                       /* i8 at 32 */, 8);
31478                                   nextPC = 5 + MATCH_p; 
31479                                   
31480 #line 617 "frontend/machine/pentium/decoder.m"
31481                                   
31482 
31483                                         stmts = instantiate(pc,  "RCRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
31484 
31485                                   
31486 
31487                                   
31488                                   
31489                                   
31490                                 }
31491                                 
31492                               } /*opt-block*/
31493                               else { 
31494                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
31495                                 goto MATCH_label_c589; 
31496                                 
31497                               } /*opt-block*/
31498                               
31499                               break;
31500                             case 2: 
31501                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31502                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31503                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31504                                       /* index at 16 */ && 
31505                                 (MATCH_w_8_16 >> 3 & 0x7) 
31506                                       /* index at 16 */ < 8)) { 
31507                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
31508                                 goto MATCH_label_c590; 
31509                                 
31510                               } /*opt-block*/
31511                               else { 
31512                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
31513                                 goto MATCH_label_c591; 
31514                                 
31515                               } /*opt-block*/
31516                               
31517                               break;
31518                             case 3: 
31519                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31520                               goto MATCH_label_c588; 
31521                               
31522                               break;
31523                             default: assert(0);
31524                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
31525                         break;
31526                       case 4: 
31527                         
31528                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
31529                             case 0: 
31530                               
31531                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
31532                                   case 0: case 1: case 2: case 3: case 6: 
31533                                   case 7: 
31534                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31535                                     goto MATCH_label_c592; 
31536                                     
31537                                     break;
31538                                   case 4: 
31539                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31540                                     if ((MATCH_w_8_16 & 0x7) 
31541                                             /* base at 16 */ == 5 && 
31542                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31543                                             /* index at 16 */ && 
31544                                       (MATCH_w_8_16 >> 3 & 0x7) 
31545                                             /* index at 16 */ < 8)) { 
31546                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
31547                                       goto MATCH_label_c594; 
31548                                       
31549                                     } /*opt-block*/
31550                                     else { 
31551                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
31552                                       goto MATCH_label_c593; 
31553                                       
31554                                     } /*opt-block*/
31555                                     
31556                                     break;
31557                                   case 5: 
31558                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
31559                                     goto MATCH_label_c595; 
31560                                     
31561                                     break;
31562                                   default: assert(0);
31563                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
31564                               break;
31565                             case 1: 
31566                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31567                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31568                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31569                                       /* index at 16 */ && 
31570                                 (MATCH_w_8_16 >> 3 & 0x7) 
31571                                       /* index at 16 */ < 8)) { 
31572                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
31573                                 { 
31574                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
31575                                   int /* [~128..127] */ i8 = 
31576                                     sign_extend((MATCH_w_8_32 & 0xff) 
31577                                                       /* i8 at 32 */, 8);
31578                                   nextPC = 5 + MATCH_p; 
31579                                   
31580 #line 611 "frontend/machine/pentium/decoder.m"
31581                                   
31582 
31583                                         stmts = instantiate(pc,  "SHLSALB.Ev.Ibod", DIS_EADDR32, DIS_I8);
31584 
31585                                   
31586 
31587                                   
31588                                   
31589                                   
31590                                 }
31591                                 
31592                               } /*opt-block*/
31593                               else { 
31594                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
31595                                 goto MATCH_label_c593; 
31596                                 
31597                               } /*opt-block*/
31598                               
31599                               break;
31600                             case 2: 
31601                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31602                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31603                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31604                                       /* index at 16 */ && 
31605                                 (MATCH_w_8_16 >> 3 & 0x7) 
31606                                       /* index at 16 */ < 8)) { 
31607                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
31608                                 goto MATCH_label_c594; 
31609                                 
31610                               } /*opt-block*/
31611                               else { 
31612                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
31613                                 goto MATCH_label_c595; 
31614                                 
31615                               } /*opt-block*/
31616                               
31617                               break;
31618                             case 3: 
31619                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31620                               goto MATCH_label_c592; 
31621                               
31622                               break;
31623                             default: assert(0);
31624                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
31625                         break;
31626                       case 5: 
31627                         
31628                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
31629                             case 0: 
31630                               
31631                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
31632                                   case 0: case 1: case 2: case 3: case 6: 
31633                                   case 7: 
31634                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31635                                     goto MATCH_label_c596; 
31636                                     
31637                                     break;
31638                                   case 4: 
31639                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31640                                     if ((MATCH_w_8_16 & 0x7) 
31641                                             /* base at 16 */ == 5 && 
31642                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31643                                             /* index at 16 */ && 
31644                                       (MATCH_w_8_16 >> 3 & 0x7) 
31645                                             /* index at 16 */ < 8)) { 
31646                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
31647                                       goto MATCH_label_c598; 
31648                                       
31649                                     } /*opt-block*/
31650                                     else { 
31651                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
31652                                       goto MATCH_label_c597; 
31653                                       
31654                                     } /*opt-block*/
31655                                     
31656                                     break;
31657                                   case 5: 
31658                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
31659                                     goto MATCH_label_c599; 
31660                                     
31661                                     break;
31662                                   default: assert(0);
31663                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
31664                               break;
31665                             case 1: 
31666                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31667                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31668                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31669                                       /* index at 16 */ && 
31670                                 (MATCH_w_8_16 >> 3 & 0x7) 
31671                                       /* index at 16 */ < 8)) { 
31672                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
31673                                 { 
31674                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
31675                                   int /* [~128..127] */ i8 = 
31676                                     sign_extend((MATCH_w_8_32 & 0xff) 
31677                                                       /* i8 at 32 */, 8);
31678                                   nextPC = 5 + MATCH_p; 
31679                                   
31680 #line 605 "frontend/machine/pentium/decoder.m"
31681                                   
31682 
31683                                         stmts = instantiate(pc,  "SHRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
31684 
31685                                   
31686 
31687                                   
31688                                   
31689                                   
31690                                 }
31691                                 
31692                               } /*opt-block*/
31693                               else { 
31694                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
31695                                 goto MATCH_label_c597; 
31696                                 
31697                               } /*opt-block*/
31698                               
31699                               break;
31700                             case 2: 
31701                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31702                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31703                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31704                                       /* index at 16 */ && 
31705                                 (MATCH_w_8_16 >> 3 & 0x7) 
31706                                       /* index at 16 */ < 8)) { 
31707                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
31708                                 goto MATCH_label_c598; 
31709                                 
31710                               } /*opt-block*/
31711                               else { 
31712                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
31713                                 goto MATCH_label_c599; 
31714                                 
31715                               } /*opt-block*/
31716                               
31717                               break;
31718                             case 3: 
31719                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31720                               goto MATCH_label_c596; 
31721                               
31722                               break;
31723                             default: assert(0);
31724                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
31725                         break;
31726                       case 6: 
31727                         goto MATCH_label_c64; break;
31728                       case 7: 
31729                         
31730                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
31731                             case 0: 
31732                               
31733                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
31734                                   case 0: case 1: case 2: case 3: case 6: 
31735                                   case 7: 
31736                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31737                                     goto MATCH_label_c600; 
31738                                     
31739                                     break;
31740                                   case 4: 
31741                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31742                                     if ((MATCH_w_8_16 & 0x7) 
31743                                             /* base at 16 */ == 5 && 
31744                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31745                                             /* index at 16 */ && 
31746                                       (MATCH_w_8_16 >> 3 & 0x7) 
31747                                             /* index at 16 */ < 8)) { 
31748                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
31749                                       goto MATCH_label_c602; 
31750                                       
31751                                     } /*opt-block*/
31752                                     else { 
31753                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
31754                                       goto MATCH_label_c601; 
31755                                       
31756                                     } /*opt-block*/
31757                                     
31758                                     break;
31759                                   case 5: 
31760                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
31761                                     goto MATCH_label_c603; 
31762                                     
31763                                     break;
31764                                   default: assert(0);
31765                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
31766                               break;
31767                             case 1: 
31768                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31769                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31770                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31771                                       /* index at 16 */ && 
31772                                 (MATCH_w_8_16 >> 3 & 0x7) 
31773                                       /* index at 16 */ < 8)) { 
31774                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
31775                                 { 
31776                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
31777                                   int /* [~128..127] */ i8 = 
31778                                     sign_extend((MATCH_w_8_32 & 0xff) 
31779                                                       /* i8 at 32 */, 8);
31780                                   nextPC = 5 + MATCH_p; 
31781                                   
31782 #line 599 "frontend/machine/pentium/decoder.m"
31783                                   
31784 
31785                                         stmts = instantiate(pc,  "SARB.Ev.Ibod", DIS_EADDR32, DIS_I8);
31786 
31787                                   
31788 
31789                                   
31790                                   
31791                                   
31792                                 }
31793                                 
31794                               } /*opt-block*/
31795                               else { 
31796                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
31797                                 goto MATCH_label_c601; 
31798                                 
31799                               } /*opt-block*/
31800                               
31801                               break;
31802                             case 2: 
31803                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31804                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31805                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31806                                       /* index at 16 */ && 
31807                                 (MATCH_w_8_16 >> 3 & 0x7) 
31808                                       /* index at 16 */ < 8)) { 
31809                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
31810                                 goto MATCH_label_c602; 
31811                                 
31812                               } /*opt-block*/
31813                               else { 
31814                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
31815                                 goto MATCH_label_c603; 
31816                                 
31817                               } /*opt-block*/
31818                               
31819                               break;
31820                             case 3: 
31821                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31822                               goto MATCH_label_c600; 
31823                               
31824                               break;
31825                             default: assert(0);
31826                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
31827                         break;
31828                       default: assert(0);
31829                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
31830                   
31831                   break;
31832                 case 2: 
31833                   MATCH_w_16_8 = getWord(1 + MATCH_p); 
31834                   { 
31835                     unsigned i16 = (MATCH_w_16_8 & 0xffff) /* i16 at 8 */;
31836                     nextPC = 3 + MATCH_p; 
31837                     
31838 #line 484 "frontend/machine/pentium/decoder.m"
31839                     
31840 
31841                             stmts = instantiate(pc,  "RET.Iw", DIS_I16);
31842 
31843                             ReturnStatement *ret = new ReturnStatement;
31844 
31845                             result.rtl = new RTL(pc, stmts);
31846 
31847                             result.rtl->appendStmt(ret);
31848 
31849                     
31850 
31851                     
31852                     
31853                     
31854                   }
31855                   
31856                   break;
31857                 case 3: 
31858                   nextPC = 1 + MATCH_p; 
31859                   
31860 #line 495 "frontend/machine/pentium/decoder.m"
31861                   
31862 
31863                         stmts = instantiate(pc,  "RET");
31864 
31865                         result.rtl = new RTL(pc, stmts);
31866 
31867                         result.rtl->appendStmt(new ReturnStatement);
31868 
31869                   
31870 
31871                   //     | REPNE() =>
31872 
31873                   //        stmts = instantiate(pc,  "REPNE");
31874 
31875                   
31876 
31877                   //    | REP() =>
31878 
31879                   //        stmts = instantiate(pc,  "REP");
31880 
31881                   
31882 
31883                   
31884                   
31885                   
31886                   
31887                   break;
31888                 case 4: 
31889                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
31890                   
31891                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
31892                       case 0: 
31893                         
31894                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
31895                             case 0: case 1: case 2: case 3: case 6: case 7: 
31896                               { 
31897                                 unsigned Mem = 1 + addressToPC(MATCH_p);
31898                                 unsigned reg = 
31899                                   (MATCH_w_8_8 >> 3 & 0x7) 
31900                                         /* reg_opcode at 8 */;
31901                                 nextPC = 2 + MATCH_p; 
31902                                 
31903 #line 1067 "frontend/machine/pentium/decoder.m"
31904                                 
31905 
31906                                         stmts = instantiate(pc,  "LES", DIS_REG32, DIS_MEM);
31907 
31908                                 
31909 
31910                                 
31911                                 
31912                                 
31913                               }
31914                               
31915                               break;
31916                             case 4: 
31917                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31918                               if ((MATCH_w_8_16 & 0x7) 
31919                                       /* base at 16 */ == 5 && 
31920                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31921                                       /* index at 16 */ && 
31922                                 (MATCH_w_8_16 >> 3 & 0x7) 
31923                                       /* index at 16 */ < 8)) 
31924                                 goto MATCH_label_c605;  /*opt-block+*/
31925                               else 
31926                                 goto MATCH_label_c604;  /*opt-block+*/
31927                               
31928                               break;
31929                             case 5: 
31930                               goto MATCH_label_c606; break;
31931                             default: assert(0);
31932                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
31933                         break;
31934                       case 1: 
31935                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
31936                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31937                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31938                                 /* index at 16 */ && 
31939                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
31940                           unsigned Mem = 1 + addressToPC(MATCH_p);
31941                           unsigned reg = 
31942                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
31943                           nextPC = 4 + MATCH_p; 
31944                           
31945 #line 1067 "frontend/machine/pentium/decoder.m"
31946                           
31947 
31948                                 stmts = instantiate(pc,  "LES", DIS_REG32, DIS_MEM);
31949 
31950                           
31951 
31952                           
31953                           
31954                           
31955                         } /*opt-block*//*opt-block+*/
31956                         else 
31957                           goto MATCH_label_c604;  /*opt-block+*/
31958                         
31959                         break;
31960                       case 2: 
31961                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
31962                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31963                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31964                                 /* index at 16 */ && 
31965                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
31966                           goto MATCH_label_c605;  /*opt-block+*/
31967                         else 
31968                           goto MATCH_label_c606;  /*opt-block+*/
31969                         
31970                         break;
31971                       case 3: 
31972                         goto MATCH_label_c64; break;
31973                       default: assert(0);
31974                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
31975                   
31976                   break;
31977                 case 5: 
31978                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
31979                   
31980                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
31981                       case 0: 
31982                         
31983                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
31984                             case 0: case 1: case 2: case 3: case 6: case 7: 
31985                               { 
31986                                 unsigned Mem = 1 + addressToPC(MATCH_p);
31987                                 unsigned reg = 
31988                                   (MATCH_w_8_8 >> 3 & 0x7) 
31989                                         /* reg_opcode at 8 */;
31990                                 nextPC = 2 + MATCH_p; 
31991                                 
31992 #line 1079 "frontend/machine/pentium/decoder.m"
31993                                 
31994 
31995                                         stmts = instantiate(pc,  "LDS", DIS_REG32, DIS_MEM);
31996 
31997                                 
31998 
31999                                 
32000                                 
32001                                 
32002                               }
32003                               
32004                               break;
32005                             case 4: 
32006                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32007                               if ((MATCH_w_8_16 & 0x7) 
32008                                       /* base at 16 */ == 5 && 
32009                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32010                                       /* index at 16 */ && 
32011                                 (MATCH_w_8_16 >> 3 & 0x7) 
32012                                       /* index at 16 */ < 8)) 
32013                                 goto MATCH_label_c608;  /*opt-block+*/
32014                               else 
32015                                 goto MATCH_label_c607;  /*opt-block+*/
32016                               
32017                               break;
32018                             case 5: 
32019                               goto MATCH_label_c609; break;
32020                             default: assert(0);
32021                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
32022                         break;
32023                       case 1: 
32024                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
32025                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32026                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32027                                 /* index at 16 */ && 
32028                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
32029                           unsigned Mem = 1 + addressToPC(MATCH_p);
32030                           unsigned reg = 
32031                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
32032                           nextPC = 4 + MATCH_p; 
32033                           
32034 #line 1079 "frontend/machine/pentium/decoder.m"
32035                           
32036 
32037                                 stmts = instantiate(pc,  "LDS", DIS_REG32, DIS_MEM);
32038 
32039                           
32040 
32041                           
32042                           
32043                           
32044                         } /*opt-block*//*opt-block+*/
32045                         else 
32046                           goto MATCH_label_c607;  /*opt-block+*/
32047                         
32048                         break;
32049                       case 2: 
32050                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
32051                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32052                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32053                                 /* index at 16 */ && 
32054                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
32055                           goto MATCH_label_c608;  /*opt-block+*/
32056                         else 
32057                           goto MATCH_label_c609;  /*opt-block+*/
32058                         
32059                         break;
32060                       case 3: 
32061                         goto MATCH_label_c64; break;
32062                       default: assert(0);
32063                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
32064                   
32065                   break;
32066                 case 6: 
32067                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
32068                   if ((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */ == 0) 
32069                     
32070                       switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
32071                         case 0: 
32072                           
32073                             switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
32074                               case 0: case 1: case 2: case 3: case 6: case 7: 
32075                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
32076                                 goto MATCH_label_c610; 
32077                                 
32078                                 break;
32079                               case 4: 
32080                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
32081                                 if ((MATCH_w_8_16 & 0x7) 
32082                                         /* base at 16 */ == 5 && 
32083                                   (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32084                                         /* index at 16 */ && 
32085                                   (MATCH_w_8_16 >> 3 & 0x7) 
32086                                         /* index at 16 */ < 8)) { 
32087                                   MATCH_w_8_56 = getByte(7 + MATCH_p); 
32088                                   goto MATCH_label_c612; 
32089                                   
32090                                 } /*opt-block*/
32091                                 else { 
32092                                   MATCH_w_8_24 = getByte(3 + MATCH_p); 
32093                                   goto MATCH_label_c611; 
32094                                   
32095                                 } /*opt-block*/
32096                                 
32097                                 break;
32098                               case 5: 
32099                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
32100                                 goto MATCH_label_c613; 
32101                                 
32102                                 break;
32103                               default: assert(0);
32104                             } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
32105                           break;
32106                         case 1: 
32107                           MATCH_w_8_16 = getByte(2 + MATCH_p); 
32108                           if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32109                             (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32110                                   /* index at 16 */ && 
32111                             (MATCH_w_8_16 >> 3 & 0x7) 
32112                                   /* index at 16 */ < 8)) { 
32113                             MATCH_w_8_32 = getByte(4 + MATCH_p); 
32114                             { 
32115                               unsigned Eaddr = 1 + addressToPC(MATCH_p);
32116                               int /* [~128..127] */ i8 = 
32117                                 sign_extend((MATCH_w_8_32 & 0xff) 
32118                                                   /* i8 at 32 */, 8);
32119                               nextPC = 5 + MATCH_p; 
32120                               
32121 #line 986 "frontend/machine/pentium/decoder.m"
32122                               
32123 
32124                                     stmts = instantiate(pc,  "MOV.Eb.Ib", DIS_EADDR8, DIS_I8);
32125 
32126                               
32127 
32128                               
32129                               
32130                               
32131                             }
32132                             
32133                           } /*opt-block*/
32134                           else { 
32135                             MATCH_w_8_24 = getByte(3 + MATCH_p); 
32136                             goto MATCH_label_c611; 
32137                             
32138                           } /*opt-block*/
32139                           
32140                           break;
32141                         case 2: 
32142                           MATCH_w_8_16 = getByte(2 + MATCH_p); 
32143                           if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32144                             (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32145                                   /* index at 16 */ && 
32146                             (MATCH_w_8_16 >> 3 & 0x7) 
32147                                   /* index at 16 */ < 8)) { 
32148                             MATCH_w_8_56 = getByte(7 + MATCH_p); 
32149                             goto MATCH_label_c612; 
32150                             
32151                           } /*opt-block*/
32152                           else { 
32153                             MATCH_w_8_48 = getByte(6 + MATCH_p); 
32154                             goto MATCH_label_c613; 
32155                             
32156                           } /*opt-block*/
32157                           
32158                           break;
32159                         case 3: 
32160                           MATCH_w_8_16 = getByte(2 + MATCH_p); 
32161                           goto MATCH_label_c610; 
32162                           
32163                           break;
32164                         default: assert(0);
32165                       } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/  
32166                   else 
32167                     goto MATCH_label_c64;  /*opt-block+*/
32168                   
32169                   break;
32170                 case 7: 
32171                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
32172                   if ((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */ == 0) 
32173                     
32174                       switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
32175                         case 0: 
32176                           
32177                             switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
32178                               case 0: case 1: case 2: case 3: case 6: case 7: 
32179                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
32180                                 goto MATCH_label_c614; 
32181                                 
32182                                 break;
32183                               case 4: 
32184                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
32185                                 if ((MATCH_w_8_16 & 0x7) 
32186                                         /* base at 16 */ == 5 && 
32187                                   (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32188                                         /* index at 16 */ && 
32189                                   (MATCH_w_8_16 >> 3 & 0x7) 
32190                                         /* index at 16 */ < 8)) { 
32191                                   MATCH_w_32_56 = getDword(7 + MATCH_p); 
32192                                   goto MATCH_label_c616; 
32193                                   
32194                                 } /*opt-block*/
32195                                 else { 
32196                                   MATCH_w_32_24 = getDword(3 + MATCH_p); 
32197                                   goto MATCH_label_c615; 
32198                                   
32199                                 } /*opt-block*/
32200                                 
32201                                 break;
32202                               case 5: 
32203                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
32204                                 goto MATCH_label_c617; 
32205                                 
32206                                 break;
32207                               default: assert(0);
32208                             } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
32209                           break;
32210                         case 1: 
32211                           MATCH_w_8_16 = getByte(2 + MATCH_p); 
32212                           if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32213                             (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32214                                   /* index at 16 */ && 
32215                             (MATCH_w_8_16 >> 3 & 0x7) 
32216                                   /* index at 16 */ < 8)) { 
32217                             MATCH_w_32_32 = getDword(4 + MATCH_p); 
32218                             { 
32219                               unsigned Eaddr = 1 + addressToPC(MATCH_p);
32220                               unsigned i32 = MATCH_w_32_32 /* i32 at 32 */;
32221                               nextPC = 8 + MATCH_p; 
32222                               
32223 #line 980 "frontend/machine/pentium/decoder.m"
32224                               
32225 
32226                                     stmts = instantiate(pc,  "MOV.Ed.Ivod", DIS_EADDR32, DIS_I32);
32227 
32228                               
32229 
32230                               
32231                               
32232                               
32233                             }
32234                             
32235                           } /*opt-block*/
32236                           else { 
32237                             MATCH_w_32_24 = getDword(3 + MATCH_p); 
32238                             goto MATCH_label_c615; 
32239                             
32240                           } /*opt-block*/
32241                           
32242                           break;
32243                         case 2: 
32244                           MATCH_w_8_16 = getByte(2 + MATCH_p); 
32245                           if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32246                             (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32247                                   /* index at 16 */ && 
32248                             (MATCH_w_8_16 >> 3 & 0x7) 
32249                                   /* index at 16 */ < 8)) { 
32250                             MATCH_w_32_56 = getDword(7 + MATCH_p); 
32251                             goto MATCH_label_c616; 
32252                             
32253                           } /*opt-block*/
32254                           else { 
32255                             MATCH_w_32_48 = getDword(6 + MATCH_p); 
32256                             goto MATCH_label_c617; 
32257                             
32258                           } /*opt-block*/
32259                           
32260                           break;
32261                         case 3: 
32262                           MATCH_w_32_16 = getDword(2 + MATCH_p); 
32263                           goto MATCH_label_c614; 
32264                           
32265                           break;
32266                         default: assert(0);
32267                       } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/  
32268                   else 
32269                     goto MATCH_label_c64;  /*opt-block+*/
32270                   
32271                   break;
32272                 default: assert(0);
32273               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
32274             break;
32275           case 13: 
32276             
32277               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
32278                 case 0: 
32279                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
32280                   
32281                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
32282                       case 0: 
32283                         
32284                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
32285                             case 0: 
32286                               
32287                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
32288                                   case 0: case 1: case 2: case 3: case 6: 
32289                                   case 7: 
32290                                     goto MATCH_label_c618; break;
32291                                   case 4: 
32292                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
32293                                     if ((MATCH_w_8_16 & 0x7) 
32294                                             /* base at 16 */ == 5 && 
32295                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32296                                             /* index at 16 */ && 
32297                                       (MATCH_w_8_16 >> 3 & 0x7) 
32298                                             /* index at 16 */ < 8)) 
32299                                       goto MATCH_label_c620;  /*opt-block+*/
32300                                     else 
32301                                       goto MATCH_label_c619;  /*opt-block+*/
32302                                     
32303                                     break;
32304                                   case 5: 
32305                                     goto MATCH_label_c621; break;
32306                                   default: assert(0);
32307                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
32308                               break;
32309                             case 1: 
32310                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32311                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32312                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32313                                       /* index at 16 */ && 
32314                                 (MATCH_w_8_16 >> 3 & 0x7) 
32315                                       /* index at 16 */ < 8)) { 
32316                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
32317                                 nextPC = 4 + MATCH_p; 
32318                                 
32319 #line 785 "frontend/machine/pentium/decoder.m"
32320                                 
32321 
32322                                         stmts = instantiate(pc,  "ROLB.Eb.1", DIS_EADDR8);
32323 
32324                                 
32325 
32326                                     // There is no SSL for these, so don't call instantiate, it will only
32327 
32328                                     // cause an assert failure. Also, may as well treat these as invalid instr
32329 
32330                                 //    | PUSHFod() =>
32331 
32332                                 //        stmts = instantiate(pc,  "PUSHFod");
32333 
32334                                 
32335 
32336                                 //    | PUSHFow() =>
32337 
32338                                 //        stmts = instantiate(pc,  "PUSHFow");
32339 
32340                                 
32341 
32342                                 //    | PUSHAod() =>
32343 
32344                                 //        stmts = instantiate(pc,  "PUSHAod");
32345 
32346                                 
32347 
32348                                 //    | PUSHAow() =>
32349 
32350                                 //        stmts = instantiate(pc,  "PUSHAow");
32351 
32352                                 
32353 
32354                                 
32355                                 
32356                                 
32357                               } /*opt-block*//*opt-block+*/
32358                               else 
32359                                 goto MATCH_label_c619;  /*opt-block+*/
32360                               
32361                               break;
32362                             case 2: 
32363                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32364                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32365                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32366                                       /* index at 16 */ && 
32367                                 (MATCH_w_8_16 >> 3 & 0x7) 
32368                                       /* index at 16 */ < 8)) 
32369                                 goto MATCH_label_c620;  /*opt-block+*/
32370                               else 
32371                                 goto MATCH_label_c621;  /*opt-block+*/
32372                               
32373                               break;
32374                             case 3: 
32375                               goto MATCH_label_c618; break;
32376                             default: assert(0);
32377                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
32378                         break;
32379                       case 1: 
32380                         
32381                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
32382                             case 0: 
32383                               
32384                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
32385                                   case 0: case 1: case 2: case 3: case 6: 
32386                                   case 7: 
32387                                     goto MATCH_label_c622; break;
32388                                   case 4: 
32389                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
32390                                     if ((MATCH_w_8_16 & 0x7) 
32391                                             /* base at 16 */ == 5 && 
32392                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32393                                             /* index at 16 */ && 
32394                                       (MATCH_w_8_16 >> 3 & 0x7) 
32395                                             /* index at 16 */ < 8)) 
32396                                       goto MATCH_label_c624;  /*opt-block+*/
32397                                     else 
32398                                       goto MATCH_label_c623;  /*opt-block+*/
32399                                     
32400                                     break;
32401                                   case 5: 
32402                                     goto MATCH_label_c625; break;
32403                                   default: assert(0);
32404                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
32405                               break;
32406                             case 1: 
32407                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32408                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32409                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32410                                       /* index at 16 */ && 
32411                                 (MATCH_w_8_16 >> 3 & 0x7) 
32412                                       /* index at 16 */ < 8)) { 
32413                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
32414                                 nextPC = 4 + MATCH_p; 
32415                                 
32416 #line 779 "frontend/machine/pentium/decoder.m"
32417                                 
32418 
32419                                         stmts = instantiate(pc,  "RORB.Eb.1", DIS_EADDR8);
32420 
32421                                 
32422 
32423                                 
32424                                 
32425                                 
32426                               } /*opt-block*//*opt-block+*/
32427                               else 
32428                                 goto MATCH_label_c623;  /*opt-block+*/
32429                               
32430                               break;
32431                             case 2: 
32432                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32433                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32434                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32435                                       /* index at 16 */ && 
32436                                 (MATCH_w_8_16 >> 3 & 0x7) 
32437                                       /* index at 16 */ < 8)) 
32438                                 goto MATCH_label_c624;  /*opt-block+*/
32439                               else 
32440                                 goto MATCH_label_c625;  /*opt-block+*/
32441                               
32442                               break;
32443                             case 3: 
32444                               goto MATCH_label_c622; break;
32445                             default: assert(0);
32446                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
32447                         break;
32448                       case 2: 
32449                         
32450                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
32451                             case 0: 
32452                               
32453                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
32454                                   case 0: case 1: case 2: case 3: case 6: 
32455                                   case 7: 
32456                                     goto MATCH_label_c626; break;
32457                                   case 4: 
32458                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
32459                                     if ((MATCH_w_8_16 & 0x7) 
32460                                             /* base at 16 */ == 5 && 
32461                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32462                                             /* index at 16 */ && 
32463                                       (MATCH_w_8_16 >> 3 & 0x7) 
32464                                             /* index at 16 */ < 8)) 
32465                                       goto MATCH_label_c628;  /*opt-block+*/
32466                                     else 
32467                                       goto MATCH_label_c627;  /*opt-block+*/
32468                                     
32469                                     break;
32470                                   case 5: 
32471                                     goto MATCH_label_c629; break;
32472                                   default: assert(0);
32473                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
32474                               break;
32475                             case 1: 
32476                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32477                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32478                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32479                                       /* index at 16 */ && 
32480                                 (MATCH_w_8_16 >> 3 & 0x7) 
32481                                       /* index at 16 */ < 8)) { 
32482                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
32483                                 nextPC = 4 + MATCH_p; 
32484                                 
32485 #line 773 "frontend/machine/pentium/decoder.m"
32486                                 
32487 
32488                                         stmts = instantiate(pc,  "RCLB.Eb.1", DIS_EADDR8);
32489 
32490                                 
32491 
32492                                 
32493                                 
32494                                 
32495                               } /*opt-block*//*opt-block+*/
32496                               else 
32497                                 goto MATCH_label_c627;  /*opt-block+*/
32498                               
32499                               break;
32500                             case 2: 
32501                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32502                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32503                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32504                                       /* index at 16 */ && 
32505                                 (MATCH_w_8_16 >> 3 & 0x7) 
32506                                       /* index at 16 */ < 8)) 
32507                                 goto MATCH_label_c628;  /*opt-block+*/
32508                               else 
32509                                 goto MATCH_label_c629;  /*opt-block+*/
32510                               
32511                               break;
32512                             case 3: 
32513                               goto MATCH_label_c626; break;
32514                             default: assert(0);
32515                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
32516                         break;
32517                       case 3: 
32518                         
32519                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
32520                             case 0: 
32521                               
32522                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
32523                                   case 0: case 1: case 2: case 3: case 6: 
32524                                   case 7: 
32525                                     goto MATCH_label_c630; break;
32526                                   case 4: 
32527                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
32528                                     if ((MATCH_w_8_16 & 0x7) 
32529                                             /* base at 16 */ == 5 && 
32530                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32531                                             /* index at 16 */ && 
32532                                       (MATCH_w_8_16 >> 3 & 0x7) 
32533                                             /* index at 16 */ < 8)) 
32534                                       goto MATCH_label_c632;  /*opt-block+*/
32535                                     else 
32536                                       goto MATCH_label_c631;  /*opt-block+*/
32537                                     
32538                                     break;
32539                                   case 5: 
32540                                     goto MATCH_label_c633; break;
32541                                   default: assert(0);
32542                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
32543                               break;
32544                             case 1: 
32545                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32546                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32547                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32548                                       /* index at 16 */ && 
32549                                 (MATCH_w_8_16 >> 3 & 0x7) 
32550                                       /* index at 16 */ < 8)) { 
32551                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
32552                                 nextPC = 4 + MATCH_p; 
32553                                 
32554 #line 767 "frontend/machine/pentium/decoder.m"
32555                                 
32556 
32557                                         stmts = instantiate(pc,  "RCRB.Eb.1", DIS_EADDR8);
32558 
32559                                 
32560 
32561                                 
32562                                 
32563                                 
32564                               } /*opt-block*//*opt-block+*/
32565                               else 
32566                                 goto MATCH_label_c631;  /*opt-block+*/
32567                               
32568                               break;
32569                             case 2: 
32570                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32571                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32572                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32573                                       /* index at 16 */ && 
32574                                 (MATCH_w_8_16 >> 3 & 0x7) 
32575                                       /* index at 16 */ < 8)) 
32576                                 goto MATCH_label_c632;  /*opt-block+*/
32577                               else 
32578                                 goto MATCH_label_c633;  /*opt-block+*/
32579                               
32580                               break;
32581                             case 3: 
32582                               goto MATCH_label_c630; break;
32583                             default: assert(0);
32584                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
32585                         break;
32586                       case 4: 
32587                         
32588                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
32589                             case 0: 
32590                               
32591                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
32592                                   case 0: case 1: case 2: case 3: case 6: 
32593                                   case 7: 
32594                                     goto MATCH_label_c634; break;
32595                                   case 4: 
32596                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
32597                                     if ((MATCH_w_8_16 & 0x7) 
32598                                             /* base at 16 */ == 5 && 
32599                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32600                                             /* index at 16 */ && 
32601                                       (MATCH_w_8_16 >> 3 & 0x7) 
32602                                             /* index at 16 */ < 8)) 
32603                                       goto MATCH_label_c636;  /*opt-block+*/
32604                                     else 
32605                                       goto MATCH_label_c635;  /*opt-block+*/
32606                                     
32607                                     break;
32608                                   case 5: 
32609                                     goto MATCH_label_c637; break;
32610                                   default: assert(0);
32611                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
32612                               break;
32613                             case 1: 
32614                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32615                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32616                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32617                                       /* index at 16 */ && 
32618                                 (MATCH_w_8_16 >> 3 & 0x7) 
32619                                       /* index at 16 */ < 8)) { 
32620                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
32621                                 nextPC = 4 + MATCH_p; 
32622                                 
32623 #line 761 "frontend/machine/pentium/decoder.m"
32624                                 
32625 
32626                                         stmts = instantiate(pc,  "SHLSALB.Eb.1", DIS_EADDR8);
32627 
32628                                 
32629 
32630                                 
32631                                 
32632                                 
32633                               } /*opt-block*//*opt-block+*/
32634                               else 
32635                                 goto MATCH_label_c635;  /*opt-block+*/
32636                               
32637                               break;
32638                             case 2: 
32639                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32640                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32641                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32642                                       /* index at 16 */ && 
32643                                 (MATCH_w_8_16 >> 3 & 0x7) 
32644                                       /* index at 16 */ < 8)) 
32645                                 goto MATCH_label_c636;  /*opt-block+*/
32646                               else 
32647                                 goto MATCH_label_c637;  /*opt-block+*/
32648                               
32649                               break;
32650                             case 3: 
32651                               goto MATCH_label_c634; break;
32652                             default: assert(0);
32653                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
32654                         break;
32655                       case 5: 
32656                         
32657                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
32658                             case 0: 
32659                               
32660                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
32661                                   case 0: case 1: case 2: case 3: case 6: 
32662                                   case 7: 
32663                                     goto MATCH_label_c638; break;
32664                                   case 4: 
32665                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
32666                                     if ((MATCH_w_8_16 & 0x7) 
32667                                             /* base at 16 */ == 5 && 
32668                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32669                                             /* index at 16 */ && 
32670                                       (MATCH_w_8_16 >> 3 & 0x7) 
32671                                             /* index at 16 */ < 8)) 
32672                                       goto MATCH_label_c640;  /*opt-block+*/
32673                                     else 
32674                                       goto MATCH_label_c639;  /*opt-block+*/
32675                                     
32676                                     break;
32677                                   case 5: 
32678                                     goto MATCH_label_c641; break;
32679                                   default: assert(0);
32680                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
32681                               break;
32682                             case 1: 
32683                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32684                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32685                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32686                                       /* index at 16 */ && 
32687                                 (MATCH_w_8_16 >> 3 & 0x7) 
32688                                       /* index at 16 */ < 8)) { 
32689                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
32690                                 nextPC = 4 + MATCH_p; 
32691                                 
32692 #line 755 "frontend/machine/pentium/decoder.m"
32693                                 
32694 
32695                                         stmts = instantiate(pc,  "SHRB.Eb.1", DIS_EADDR8);
32696 
32697                                 
32698 
32699                                 
32700                                 
32701                                 
32702                               } /*opt-block*//*opt-block+*/
32703                               else 
32704                                 goto MATCH_label_c639;  /*opt-block+*/
32705                               
32706                               break;
32707                             case 2: 
32708                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32709                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32710                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32711                                       /* index at 16 */ && 
32712                                 (MATCH_w_8_16 >> 3 & 0x7) 
32713                                       /* index at 16 */ < 8)) 
32714                                 goto MATCH_label_c640;  /*opt-block+*/
32715                               else 
32716                                 goto MATCH_label_c641;  /*opt-block+*/
32717                               
32718                               break;
32719                             case 3: 
32720                               goto MATCH_label_c638; break;
32721                             default: assert(0);
32722                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
32723                         break;
32724                       case 6: 
32725                         goto MATCH_label_c64; break;
32726                       case 7: 
32727                         
32728                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
32729                             case 0: 
32730                               
32731                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
32732                                   case 0: case 1: case 2: case 3: case 6: 
32733                                   case 7: 
32734                                     goto MATCH_label_c642; break;
32735                                   case 4: 
32736                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
32737                                     if ((MATCH_w_8_16 & 0x7) 
32738                                             /* base at 16 */ == 5 && 
32739                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32740                                             /* index at 16 */ && 
32741                                       (MATCH_w_8_16 >> 3 & 0x7) 
32742                                             /* index at 16 */ < 8)) 
32743                                       goto MATCH_label_c644;  /*opt-block+*/
32744                                     else 
32745                                       goto MATCH_label_c643;  /*opt-block+*/
32746                                     
32747                                     break;
32748                                   case 5: 
32749                                     goto MATCH_label_c645; break;
32750                                   default: assert(0);
32751                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
32752                               break;
32753                             case 1: 
32754                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32755                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32756                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32757                                       /* index at 16 */ && 
32758                                 (MATCH_w_8_16 >> 3 & 0x7) 
32759                                       /* index at 16 */ < 8)) { 
32760                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
32761                                 nextPC = 4 + MATCH_p; 
32762                                 
32763 #line 749 "frontend/machine/pentium/decoder.m"
32764                                 
32765 
32766                                         stmts = instantiate(pc,  "SARB.Eb.1", DIS_EADDR16);
32767 
32768                                 
32769 
32770                                 
32771                                 
32772                                 
32773                               } /*opt-block*//*opt-block+*/
32774                               else 
32775                                 goto MATCH_label_c643;  /*opt-block+*/
32776                               
32777                               break;
32778                             case 2: 
32779                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32780                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32781                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32782                                       /* index at 16 */ && 
32783                                 (MATCH_w_8_16 >> 3 & 0x7) 
32784                                       /* index at 16 */ < 8)) 
32785                                 goto MATCH_label_c644;  /*opt-block+*/
32786                               else 
32787                                 goto MATCH_label_c645;  /*opt-block+*/
32788                               
32789                               break;
32790                             case 3: 
32791                               goto MATCH_label_c642; break;
32792                             default: assert(0);
32793                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
32794                         break;
32795                       default: assert(0);
32796                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
32797                   
32798                   break;
32799                 case 1: 
32800                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
32801                   
32802                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
32803                       case 0: 
32804                         
32805                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
32806                             case 0: 
32807                               
32808                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
32809                                   case 0: case 1: case 2: case 3: case 6: 
32810                                   case 7: 
32811                                     goto MATCH_label_c646; break;
32812                                   case 4: 
32813                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
32814                                     if ((MATCH_w_8_16 & 0x7) 
32815                                             /* base at 16 */ == 5 && 
32816                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32817                                             /* index at 16 */ && 
32818                                       (MATCH_w_8_16 >> 3 & 0x7) 
32819                                             /* index at 16 */ < 8)) 
32820                                       goto MATCH_label_c648;  /*opt-block+*/
32821                                     else 
32822                                       goto MATCH_label_c647;  /*opt-block+*/
32823                                     
32824                                     break;
32825                                   case 5: 
32826                                     goto MATCH_label_c649; break;
32827                                   default: assert(0);
32828                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
32829                               break;
32830                             case 1: 
32831                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32832                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32833                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32834                                       /* index at 16 */ && 
32835                                 (MATCH_w_8_16 >> 3 & 0x7) 
32836                                       /* index at 16 */ < 8)) { 
32837                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
32838                                 nextPC = 4 + MATCH_p; 
32839                                 
32840 #line 740 "frontend/machine/pentium/decoder.m"
32841                                 
32842 
32843                                         stmts = instantiate(pc,  "ROLB.Ev.1od", DIS_EADDR32);
32844 
32845                                 
32846 
32847                                 
32848                                 
32849                                 
32850                               } /*opt-block*//*opt-block+*/
32851                               else 
32852                                 goto MATCH_label_c647;  /*opt-block+*/
32853                               
32854                               break;
32855                             case 2: 
32856                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32857                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32858                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32859                                       /* index at 16 */ && 
32860                                 (MATCH_w_8_16 >> 3 & 0x7) 
32861                                       /* index at 16 */ < 8)) 
32862                                 goto MATCH_label_c648;  /*opt-block+*/
32863                               else 
32864                                 goto MATCH_label_c649;  /*opt-block+*/
32865                               
32866                               break;
32867                             case 3: 
32868                               goto MATCH_label_c646; break;
32869                             default: assert(0);
32870                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
32871                         break;
32872                       case 1: 
32873                         
32874                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
32875                             case 0: 
32876                               
32877                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
32878                                   case 0: case 1: case 2: case 3: case 6: 
32879                                   case 7: 
32880                                     goto MATCH_label_c650; break;
32881                                   case 4: 
32882                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
32883                                     if ((MATCH_w_8_16 & 0x7) 
32884                                             /* base at 16 */ == 5 && 
32885                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32886                                             /* index at 16 */ && 
32887                                       (MATCH_w_8_16 >> 3 & 0x7) 
32888                                             /* index at 16 */ < 8)) 
32889                                       goto MATCH_label_c652;  /*opt-block+*/
32890                                     else 
32891                                       goto MATCH_label_c651;  /*opt-block+*/
32892                                     
32893                                     break;
32894                                   case 5: 
32895                                     goto MATCH_label_c653; break;
32896                                   default: assert(0);
32897                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
32898                               break;
32899                             case 1: 
32900                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32901                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32902                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32903                                       /* index at 16 */ && 
32904                                 (MATCH_w_8_16 >> 3 & 0x7) 
32905                                       /* index at 16 */ < 8)) { 
32906                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
32907                                 nextPC = 4 + MATCH_p; 
32908                                 
32909 #line 728 "frontend/machine/pentium/decoder.m"
32910                                 
32911 
32912                                         stmts = instantiate(pc,  "RORB.Ev.1od", DIS_EADDR32);
32913 
32914                                 
32915 
32916                                 
32917                                 
32918                                 
32919                               } /*opt-block*//*opt-block+*/
32920                               else 
32921                                 goto MATCH_label_c651;  /*opt-block+*/
32922                               
32923                               break;
32924                             case 2: 
32925                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32926                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32927                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32928                                       /* index at 16 */ && 
32929                                 (MATCH_w_8_16 >> 3 & 0x7) 
32930                                       /* index at 16 */ < 8)) 
32931                                 goto MATCH_label_c652;  /*opt-block+*/
32932                               else 
32933                                 goto MATCH_label_c653;  /*opt-block+*/
32934                               
32935                               break;
32936                             case 3: 
32937                               goto MATCH_label_c650; break;
32938                             default: assert(0);
32939                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
32940                         break;
32941                       case 2: 
32942                         
32943                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
32944                             case 0: 
32945                               
32946                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
32947                                   case 0: case 1: case 2: case 3: case 6: 
32948                                   case 7: 
32949                                     goto MATCH_label_c654; break;
32950                                   case 4: 
32951                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
32952                                     if ((MATCH_w_8_16 & 0x7) 
32953                                             /* base at 16 */ == 5 && 
32954                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32955                                             /* index at 16 */ && 
32956                                       (MATCH_w_8_16 >> 3 & 0x7) 
32957                                             /* index at 16 */ < 8)) 
32958                                       goto MATCH_label_c656;  /*opt-block+*/
32959                                     else 
32960                                       goto MATCH_label_c655;  /*opt-block+*/
32961                                     
32962                                     break;
32963                                   case 5: 
32964                                     goto MATCH_label_c657; break;
32965                                   default: assert(0);
32966                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
32967                               break;
32968                             case 1: 
32969                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32970                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32971                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32972                                       /* index at 16 */ && 
32973                                 (MATCH_w_8_16 >> 3 & 0x7) 
32974                                       /* index at 16 */ < 8)) { 
32975                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
32976                                 nextPC = 4 + MATCH_p; 
32977                                 
32978 #line 716 "frontend/machine/pentium/decoder.m"
32979                                 
32980 
32981                                         stmts = instantiate(pc,  "RCLB.Ev.1od", DIS_EADDR32);
32982 
32983                                 
32984 
32985                                 
32986                                 
32987                                 
32988                               } /*opt-block*//*opt-block+*/
32989                               else 
32990                                 goto MATCH_label_c655;  /*opt-block+*/
32991                               
32992                               break;
32993                             case 2: 
32994                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32995                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32996                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32997                                       /* index at 16 */ && 
32998                                 (MATCH_w_8_16 >> 3 & 0x7) 
32999                                       /* index at 16 */ < 8)) 
33000                                 goto MATCH_label_c656;  /*opt-block+*/
33001                               else 
33002                                 goto MATCH_label_c657;  /*opt-block+*/
33003                               
33004                               break;
33005                             case 3: 
33006                               goto MATCH_label_c654; break;
33007                             default: assert(0);
33008                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33009                         break;
33010                       case 3: 
33011                         
33012                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33013                             case 0: 
33014                               
33015                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33016                                   case 0: case 1: case 2: case 3: case 6: 
33017                                   case 7: 
33018                                     goto MATCH_label_c658; break;
33019                                   case 4: 
33020                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33021                                     if ((MATCH_w_8_16 & 0x7) 
33022                                             /* base at 16 */ == 5 && 
33023                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33024                                             /* index at 16 */ && 
33025                                       (MATCH_w_8_16 >> 3 & 0x7) 
33026                                             /* index at 16 */ < 8)) 
33027                                       goto MATCH_label_c660;  /*opt-block+*/
33028                                     else 
33029                                       goto MATCH_label_c659;  /*opt-block+*/
33030                                     
33031                                     break;
33032                                   case 5: 
33033                                     goto MATCH_label_c661; break;
33034                                   default: assert(0);
33035                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33036                               break;
33037                             case 1: 
33038                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33039                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33040                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33041                                       /* index at 16 */ && 
33042                                 (MATCH_w_8_16 >> 3 & 0x7) 
33043                                       /* index at 16 */ < 8)) { 
33044                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33045                                 nextPC = 4 + MATCH_p; 
33046                                 
33047 #line 704 "frontend/machine/pentium/decoder.m"
33048                                 
33049 
33050                                         stmts = instantiate(pc,  "RCRB.Ev.1od", DIS_EADDR32);
33051 
33052                                 
33053 
33054                                 
33055                                 
33056                                 
33057                               } /*opt-block*//*opt-block+*/
33058                               else 
33059                                 goto MATCH_label_c659;  /*opt-block+*/
33060                               
33061                               break;
33062                             case 2: 
33063                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33064                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33065                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33066                                       /* index at 16 */ && 
33067                                 (MATCH_w_8_16 >> 3 & 0x7) 
33068                                       /* index at 16 */ < 8)) 
33069                                 goto MATCH_label_c660;  /*opt-block+*/
33070                               else 
33071                                 goto MATCH_label_c661;  /*opt-block+*/
33072                               
33073                               break;
33074                             case 3: 
33075                               goto MATCH_label_c658; break;
33076                             default: assert(0);
33077                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33078                         break;
33079                       case 4: 
33080                         
33081                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33082                             case 0: 
33083                               
33084                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33085                                   case 0: case 1: case 2: case 3: case 6: 
33086                                   case 7: 
33087                                     goto MATCH_label_c662; break;
33088                                   case 4: 
33089                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33090                                     if ((MATCH_w_8_16 & 0x7) 
33091                                             /* base at 16 */ == 5 && 
33092                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33093                                             /* index at 16 */ && 
33094                                       (MATCH_w_8_16 >> 3 & 0x7) 
33095                                             /* index at 16 */ < 8)) 
33096                                       goto MATCH_label_c664;  /*opt-block+*/
33097                                     else 
33098                                       goto MATCH_label_c663;  /*opt-block+*/
33099                                     
33100                                     break;
33101                                   case 5: 
33102                                     goto MATCH_label_c665; break;
33103                                   default: assert(0);
33104                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33105                               break;
33106                             case 1: 
33107                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33108                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33109                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33110                                       /* index at 16 */ && 
33111                                 (MATCH_w_8_16 >> 3 & 0x7) 
33112                                       /* index at 16 */ < 8)) { 
33113                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33114                                 nextPC = 4 + MATCH_p; 
33115                                 
33116 #line 692 "frontend/machine/pentium/decoder.m"
33117                                 
33118 
33119                                         stmts = instantiate(pc,  "SHLSALB.Ev.1od", DIS_EADDR32);
33120 
33121                                 
33122 
33123                                 
33124                                 
33125                                 
33126                               } /*opt-block*//*opt-block+*/
33127                               else 
33128                                 goto MATCH_label_c663;  /*opt-block+*/
33129                               
33130                               break;
33131                             case 2: 
33132                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33133                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33134                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33135                                       /* index at 16 */ && 
33136                                 (MATCH_w_8_16 >> 3 & 0x7) 
33137                                       /* index at 16 */ < 8)) 
33138                                 goto MATCH_label_c664;  /*opt-block+*/
33139                               else 
33140                                 goto MATCH_label_c665;  /*opt-block+*/
33141                               
33142                               break;
33143                             case 3: 
33144                               goto MATCH_label_c662; break;
33145                             default: assert(0);
33146                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33147                         break;
33148                       case 5: 
33149                         
33150                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33151                             case 0: 
33152                               
33153                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33154                                   case 0: case 1: case 2: case 3: case 6: 
33155                                   case 7: 
33156                                     goto MATCH_label_c666; break;
33157                                   case 4: 
33158                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33159                                     if ((MATCH_w_8_16 & 0x7) 
33160                                             /* base at 16 */ == 5 && 
33161                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33162                                             /* index at 16 */ && 
33163                                       (MATCH_w_8_16 >> 3 & 0x7) 
33164                                             /* index at 16 */ < 8)) 
33165                                       goto MATCH_label_c668;  /*opt-block+*/
33166                                     else 
33167                                       goto MATCH_label_c667;  /*opt-block+*/
33168                                     
33169                                     break;
33170                                   case 5: 
33171                                     goto MATCH_label_c669; break;
33172                                   default: assert(0);
33173                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33174                               break;
33175                             case 1: 
33176                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33177                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33178                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33179                                       /* index at 16 */ && 
33180                                 (MATCH_w_8_16 >> 3 & 0x7) 
33181                                       /* index at 16 */ < 8)) { 
33182                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33183                                 nextPC = 4 + MATCH_p; 
33184                                 
33185 #line 680 "frontend/machine/pentium/decoder.m"
33186                                 
33187 
33188                                         stmts = instantiate(pc,  "SHRB.Ev.1od", DIS_EADDR32);
33189 
33190                                 
33191 
33192                                 
33193                                 
33194                                 
33195                               } /*opt-block*//*opt-block+*/
33196                               else 
33197                                 goto MATCH_label_c667;  /*opt-block+*/
33198                               
33199                               break;
33200                             case 2: 
33201                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33202                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33203                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33204                                       /* index at 16 */ && 
33205                                 (MATCH_w_8_16 >> 3 & 0x7) 
33206                                       /* index at 16 */ < 8)) 
33207                                 goto MATCH_label_c668;  /*opt-block+*/
33208                               else 
33209                                 goto MATCH_label_c669;  /*opt-block+*/
33210                               
33211                               break;
33212                             case 3: 
33213                               goto MATCH_label_c666; break;
33214                             default: assert(0);
33215                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33216                         break;
33217                       case 6: 
33218                         goto MATCH_label_c64; break;
33219                       case 7: 
33220                         
33221                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33222                             case 0: 
33223                               
33224                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33225                                   case 0: case 1: case 2: case 3: case 6: 
33226                                   case 7: 
33227                                     goto MATCH_label_c670; break;
33228                                   case 4: 
33229                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33230                                     if ((MATCH_w_8_16 & 0x7) 
33231                                             /* base at 16 */ == 5 && 
33232                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33233                                             /* index at 16 */ && 
33234                                       (MATCH_w_8_16 >> 3 & 0x7) 
33235                                             /* index at 16 */ < 8)) 
33236                                       goto MATCH_label_c672;  /*opt-block+*/
33237                                     else 
33238                                       goto MATCH_label_c671;  /*opt-block+*/
33239                                     
33240                                     break;
33241                                   case 5: 
33242                                     goto MATCH_label_c673; break;
33243                                   default: assert(0);
33244                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33245                               break;
33246                             case 1: 
33247                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33248                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33249                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33250                                       /* index at 16 */ && 
33251                                 (MATCH_w_8_16 >> 3 & 0x7) 
33252                                       /* index at 16 */ < 8)) { 
33253                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33254                                 nextPC = 4 + MATCH_p; 
33255                                 
33256 #line 668 "frontend/machine/pentium/decoder.m"
33257                                 
33258 
33259                                         stmts = instantiate(pc,  "SARB.Ev.1od", DIS_EADDR32);
33260 
33261                                 
33262 
33263                                 
33264                                 
33265                                 
33266                               } /*opt-block*//*opt-block+*/
33267                               else 
33268                                 goto MATCH_label_c671;  /*opt-block+*/
33269                               
33270                               break;
33271                             case 2: 
33272                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33273                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33274                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33275                                       /* index at 16 */ && 
33276                                 (MATCH_w_8_16 >> 3 & 0x7) 
33277                                       /* index at 16 */ < 8)) 
33278                                 goto MATCH_label_c672;  /*opt-block+*/
33279                               else 
33280                                 goto MATCH_label_c673;  /*opt-block+*/
33281                               
33282                               break;
33283                             case 3: 
33284                               goto MATCH_label_c670; break;
33285                             default: assert(0);
33286                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33287                         break;
33288                       default: assert(0);
33289                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
33290                   
33291                   break;
33292                 case 2: 
33293                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
33294                   
33295                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
33296                       case 0: 
33297                         
33298                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33299                             case 0: 
33300                               
33301                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33302                                   case 0: case 1: case 2: case 3: case 6: 
33303                                   case 7: 
33304                                     goto MATCH_label_c674; break;
33305                                   case 4: 
33306                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33307                                     if ((MATCH_w_8_16 & 0x7) 
33308                                             /* base at 16 */ == 5 && 
33309                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33310                                             /* index at 16 */ && 
33311                                       (MATCH_w_8_16 >> 3 & 0x7) 
33312                                             /* index at 16 */ < 8)) 
33313                                       goto MATCH_label_c676;  /*opt-block+*/
33314                                     else 
33315                                       goto MATCH_label_c675;  /*opt-block+*/
33316                                     
33317                                     break;
33318                                   case 5: 
33319                                     goto MATCH_label_c677; break;
33320                                   default: assert(0);
33321                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33322                               break;
33323                             case 1: 
33324                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33325                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33326                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33327                                       /* index at 16 */ && 
33328                                 (MATCH_w_8_16 >> 3 & 0x7) 
33329                                       /* index at 16 */ < 8)) { 
33330                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33331                                 nextPC = 4 + MATCH_p; 
33332                                 
33333 #line 782 "frontend/machine/pentium/decoder.m"
33334                                 
33335 
33336                                         stmts = instantiate(pc,  "ROLB.Eb.CL", DIS_EADDR8);
33337 
33338                                 
33339 
33340                                 
33341                                 
33342                                 
33343                               } /*opt-block*//*opt-block+*/
33344                               else 
33345                                 goto MATCH_label_c675;  /*opt-block+*/
33346                               
33347                               break;
33348                             case 2: 
33349                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33350                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33351                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33352                                       /* index at 16 */ && 
33353                                 (MATCH_w_8_16 >> 3 & 0x7) 
33354                                       /* index at 16 */ < 8)) 
33355                                 goto MATCH_label_c676;  /*opt-block+*/
33356                               else 
33357                                 goto MATCH_label_c677;  /*opt-block+*/
33358                               
33359                               break;
33360                             case 3: 
33361                               goto MATCH_label_c674; break;
33362                             default: assert(0);
33363                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33364                         break;
33365                       case 1: 
33366                         
33367                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33368                             case 0: 
33369                               
33370                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33371                                   case 0: case 1: case 2: case 3: case 6: 
33372                                   case 7: 
33373                                     goto MATCH_label_c678; break;
33374                                   case 4: 
33375                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33376                                     if ((MATCH_w_8_16 & 0x7) 
33377                                             /* base at 16 */ == 5 && 
33378                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33379                                             /* index at 16 */ && 
33380                                       (MATCH_w_8_16 >> 3 & 0x7) 
33381                                             /* index at 16 */ < 8)) 
33382                                       goto MATCH_label_c680;  /*opt-block+*/
33383                                     else 
33384                                       goto MATCH_label_c679;  /*opt-block+*/
33385                                     
33386                                     break;
33387                                   case 5: 
33388                                     goto MATCH_label_c681; break;
33389                                   default: assert(0);
33390                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33391                               break;
33392                             case 1: 
33393                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33394                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33395                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33396                                       /* index at 16 */ && 
33397                                 (MATCH_w_8_16 >> 3 & 0x7) 
33398                                       /* index at 16 */ < 8)) { 
33399                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33400                                 nextPC = 4 + MATCH_p; 
33401                                 
33402 #line 776 "frontend/machine/pentium/decoder.m"
33403                                 
33404 
33405                                         stmts = instantiate(pc,  "RORB.Eb.CL", DIS_EADDR8);
33406 
33407                                 
33408 
33409                                 
33410                                 
33411                                 
33412                               } /*opt-block*//*opt-block+*/
33413                               else 
33414                                 goto MATCH_label_c679;  /*opt-block+*/
33415                               
33416                               break;
33417                             case 2: 
33418                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33419                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33420                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33421                                       /* index at 16 */ && 
33422                                 (MATCH_w_8_16 >> 3 & 0x7) 
33423                                       /* index at 16 */ < 8)) 
33424                                 goto MATCH_label_c680;  /*opt-block+*/
33425                               else 
33426                                 goto MATCH_label_c681;  /*opt-block+*/
33427                               
33428                               break;
33429                             case 3: 
33430                               goto MATCH_label_c678; break;
33431                             default: assert(0);
33432                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33433                         break;
33434                       case 2: 
33435                         
33436                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33437                             case 0: 
33438                               
33439                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33440                                   case 0: case 1: case 2: case 3: case 6: 
33441                                   case 7: 
33442                                     goto MATCH_label_c682; break;
33443                                   case 4: 
33444                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33445                                     if ((MATCH_w_8_16 & 0x7) 
33446                                             /* base at 16 */ == 5 && 
33447                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33448                                             /* index at 16 */ && 
33449                                       (MATCH_w_8_16 >> 3 & 0x7) 
33450                                             /* index at 16 */ < 8)) 
33451                                       goto MATCH_label_c684;  /*opt-block+*/
33452                                     else 
33453                                       goto MATCH_label_c683;  /*opt-block+*/
33454                                     
33455                                     break;
33456                                   case 5: 
33457                                     goto MATCH_label_c685; break;
33458                                   default: assert(0);
33459                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33460                               break;
33461                             case 1: 
33462                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33463                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33464                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33465                                       /* index at 16 */ && 
33466                                 (MATCH_w_8_16 >> 3 & 0x7) 
33467                                       /* index at 16 */ < 8)) { 
33468                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33469                                 nextPC = 4 + MATCH_p; 
33470                                 
33471 #line 770 "frontend/machine/pentium/decoder.m"
33472                                 
33473 
33474                                         stmts = instantiate(pc,  "RCLB.Eb.CL", DIS_EADDR8);
33475 
33476                                 
33477 
33478                                 
33479                                 
33480                                 
33481                               } /*opt-block*//*opt-block+*/
33482                               else 
33483                                 goto MATCH_label_c683;  /*opt-block+*/
33484                               
33485                               break;
33486                             case 2: 
33487                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33488                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33489                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33490                                       /* index at 16 */ && 
33491                                 (MATCH_w_8_16 >> 3 & 0x7) 
33492                                       /* index at 16 */ < 8)) 
33493                                 goto MATCH_label_c684;  /*opt-block+*/
33494                               else 
33495                                 goto MATCH_label_c685;  /*opt-block+*/
33496                               
33497                               break;
33498                             case 3: 
33499                               goto MATCH_label_c682; break;
33500                             default: assert(0);
33501                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33502                         break;
33503                       case 3: 
33504                         
33505                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33506                             case 0: 
33507                               
33508                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33509                                   case 0: case 1: case 2: case 3: case 6: 
33510                                   case 7: 
33511                                     goto MATCH_label_c686; break;
33512                                   case 4: 
33513                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33514                                     if ((MATCH_w_8_16 & 0x7) 
33515                                             /* base at 16 */ == 5 && 
33516                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33517                                             /* index at 16 */ && 
33518                                       (MATCH_w_8_16 >> 3 & 0x7) 
33519                                             /* index at 16 */ < 8)) 
33520                                       goto MATCH_label_c688;  /*opt-block+*/
33521                                     else 
33522                                       goto MATCH_label_c687;  /*opt-block+*/
33523                                     
33524                                     break;
33525                                   case 5: 
33526                                     goto MATCH_label_c689; break;
33527                                   default: assert(0);
33528                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33529                               break;
33530                             case 1: 
33531                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33532                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33533                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33534                                       /* index at 16 */ && 
33535                                 (MATCH_w_8_16 >> 3 & 0x7) 
33536                                       /* index at 16 */ < 8)) { 
33537                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33538                                 nextPC = 4 + MATCH_p; 
33539                                 
33540 #line 764 "frontend/machine/pentium/decoder.m"
33541                                 
33542 
33543                                         stmts = instantiate(pc,  "RCRB.Eb.CL", DIS_EADDR8);
33544 
33545                                 
33546 
33547                                 
33548                                 
33549                                 
33550                               } /*opt-block*//*opt-block+*/
33551                               else 
33552                                 goto MATCH_label_c687;  /*opt-block+*/
33553                               
33554                               break;
33555                             case 2: 
33556                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33557                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33558                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33559                                       /* index at 16 */ && 
33560                                 (MATCH_w_8_16 >> 3 & 0x7) 
33561                                       /* index at 16 */ < 8)) 
33562                                 goto MATCH_label_c688;  /*opt-block+*/
33563                               else 
33564                                 goto MATCH_label_c689;  /*opt-block+*/
33565                               
33566                               break;
33567                             case 3: 
33568                               goto MATCH_label_c686; break;
33569                             default: assert(0);
33570                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33571                         break;
33572                       case 4: 
33573                         
33574                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33575                             case 0: 
33576                               
33577                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33578                                   case 0: case 1: case 2: case 3: case 6: 
33579                                   case 7: 
33580                                     goto MATCH_label_c690; break;
33581                                   case 4: 
33582                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33583                                     if ((MATCH_w_8_16 & 0x7) 
33584                                             /* base at 16 */ == 5 && 
33585                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33586                                             /* index at 16 */ && 
33587                                       (MATCH_w_8_16 >> 3 & 0x7) 
33588                                             /* index at 16 */ < 8)) 
33589                                       goto MATCH_label_c692;  /*opt-block+*/
33590                                     else 
33591                                       goto MATCH_label_c691;  /*opt-block+*/
33592                                     
33593                                     break;
33594                                   case 5: 
33595                                     goto MATCH_label_c693; break;
33596                                   default: assert(0);
33597                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33598                               break;
33599                             case 1: 
33600                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33601                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33602                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33603                                       /* index at 16 */ && 
33604                                 (MATCH_w_8_16 >> 3 & 0x7) 
33605                                       /* index at 16 */ < 8)) { 
33606                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33607                                 nextPC = 4 + MATCH_p; 
33608                                 
33609 #line 758 "frontend/machine/pentium/decoder.m"
33610                                 
33611 
33612                                         stmts = instantiate(pc,  "SHLSALB.Eb.CL", DIS_EADDR8);
33613 
33614                                 
33615 
33616                                 
33617                                 
33618                                 
33619                               } /*opt-block*//*opt-block+*/
33620                               else 
33621                                 goto MATCH_label_c691;  /*opt-block+*/
33622                               
33623                               break;
33624                             case 2: 
33625                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33626                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33627                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33628                                       /* index at 16 */ && 
33629                                 (MATCH_w_8_16 >> 3 & 0x7) 
33630                                       /* index at 16 */ < 8)) 
33631                                 goto MATCH_label_c692;  /*opt-block+*/
33632                               else 
33633                                 goto MATCH_label_c693;  /*opt-block+*/
33634                               
33635                               break;
33636                             case 3: 
33637                               goto MATCH_label_c690; break;
33638                             default: assert(0);
33639                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33640                         break;
33641                       case 5: 
33642                         
33643                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33644                             case 0: 
33645                               
33646                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33647                                   case 0: case 1: case 2: case 3: case 6: 
33648                                   case 7: 
33649                                     goto MATCH_label_c694; break;
33650                                   case 4: 
33651                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33652                                     if ((MATCH_w_8_16 & 0x7) 
33653                                             /* base at 16 */ == 5 && 
33654                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33655                                             /* index at 16 */ && 
33656                                       (MATCH_w_8_16 >> 3 & 0x7) 
33657                                             /* index at 16 */ < 8)) 
33658                                       goto MATCH_label_c696;  /*opt-block+*/
33659                                     else 
33660                                       goto MATCH_label_c695;  /*opt-block+*/
33661                                     
33662                                     break;
33663                                   case 5: 
33664                                     goto MATCH_label_c697; break;
33665                                   default: assert(0);
33666                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33667                               break;
33668                             case 1: 
33669                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33670                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33671                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33672                                       /* index at 16 */ && 
33673                                 (MATCH_w_8_16 >> 3 & 0x7) 
33674                                       /* index at 16 */ < 8)) { 
33675                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33676                                 nextPC = 4 + MATCH_p; 
33677                                 
33678 #line 752 "frontend/machine/pentium/decoder.m"
33679                                 
33680 
33681                                         stmts = instantiate(pc,  "SHRB.Eb.CL", DIS_EADDR8);
33682 
33683                                 
33684 
33685                                 
33686                                 
33687                                 
33688                               } /*opt-block*//*opt-block+*/
33689                               else 
33690                                 goto MATCH_label_c695;  /*opt-block+*/
33691                               
33692                               break;
33693                             case 2: 
33694                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33695                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33696                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33697                                       /* index at 16 */ && 
33698                                 (MATCH_w_8_16 >> 3 & 0x7) 
33699                                       /* index at 16 */ < 8)) 
33700                                 goto MATCH_label_c696;  /*opt-block+*/
33701                               else 
33702                                 goto MATCH_label_c697;  /*opt-block+*/
33703                               
33704                               break;
33705                             case 3: 
33706                               goto MATCH_label_c694; break;
33707                             default: assert(0);
33708                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33709                         break;
33710                       case 6: 
33711                         goto MATCH_label_c64; break;
33712                       case 7: 
33713                         
33714                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33715                             case 0: 
33716                               
33717                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33718                                   case 0: case 1: case 2: case 3: case 6: 
33719                                   case 7: 
33720                                     goto MATCH_label_c698; break;
33721                                   case 4: 
33722                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33723                                     if ((MATCH_w_8_16 & 0x7) 
33724                                             /* base at 16 */ == 5 && 
33725                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33726                                             /* index at 16 */ && 
33727                                       (MATCH_w_8_16 >> 3 & 0x7) 
33728                                             /* index at 16 */ < 8)) 
33729                                       goto MATCH_label_c700;  /*opt-block+*/
33730                                     else 
33731                                       goto MATCH_label_c699;  /*opt-block+*/
33732                                     
33733                                     break;
33734                                   case 5: 
33735                                     goto MATCH_label_c701; break;
33736                                   default: assert(0);
33737                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33738                               break;
33739                             case 1: 
33740                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33741                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33742                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33743                                       /* index at 16 */ && 
33744                                 (MATCH_w_8_16 >> 3 & 0x7) 
33745                                       /* index at 16 */ < 8)) { 
33746                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33747                                 nextPC = 4 + MATCH_p; 
33748                                 
33749 #line 746 "frontend/machine/pentium/decoder.m"
33750                                 
33751 
33752                                         stmts = instantiate(pc,  "SARB.Eb.CL", DIS_EADDR32);
33753 
33754                                 
33755 
33756                                 
33757                                 
33758                                 
33759                               } /*opt-block*//*opt-block+*/
33760                               else 
33761                                 goto MATCH_label_c699;  /*opt-block+*/
33762                               
33763                               break;
33764                             case 2: 
33765                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33766                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33767                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33768                                       /* index at 16 */ && 
33769                                 (MATCH_w_8_16 >> 3 & 0x7) 
33770                                       /* index at 16 */ < 8)) 
33771                                 goto MATCH_label_c700;  /*opt-block+*/
33772                               else 
33773                                 goto MATCH_label_c701;  /*opt-block+*/
33774                               
33775                               break;
33776                             case 3: 
33777                               goto MATCH_label_c698; break;
33778                             default: assert(0);
33779                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33780                         break;
33781                       default: assert(0);
33782                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
33783                   
33784                   break;
33785                 case 3: 
33786                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
33787                   
33788                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
33789                       case 0: 
33790                         
33791                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33792                             case 0: 
33793                               
33794                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33795                                   case 0: case 1: case 2: case 3: case 6: 
33796                                   case 7: 
33797                                     goto MATCH_label_c702; break;
33798                                   case 4: 
33799                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33800                                     if ((MATCH_w_8_16 & 0x7) 
33801                                             /* base at 16 */ == 5 && 
33802                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33803                                             /* index at 16 */ && 
33804                                       (MATCH_w_8_16 >> 3 & 0x7) 
33805                                             /* index at 16 */ < 8)) 
33806                                       goto MATCH_label_c704;  /*opt-block+*/
33807                                     else 
33808                                       goto MATCH_label_c703;  /*opt-block+*/
33809                                     
33810                                     break;
33811                                   case 5: 
33812                                     goto MATCH_label_c705; break;
33813                                   default: assert(0);
33814                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33815                               break;
33816                             case 1: 
33817                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33818                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33819                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33820                                       /* index at 16 */ && 
33821                                 (MATCH_w_8_16 >> 3 & 0x7) 
33822                                       /* index at 16 */ < 8)) { 
33823                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33824                                 nextPC = 4 + MATCH_p; 
33825                                 
33826 #line 734 "frontend/machine/pentium/decoder.m"
33827                                 
33828 
33829                                         stmts = instantiate(pc,  "ROLB.Ev.CLod", DIS_EADDR32);
33830 
33831                                 
33832 
33833                                 
33834                                 
33835                                 
33836                               } /*opt-block*//*opt-block+*/
33837                               else 
33838                                 goto MATCH_label_c703;  /*opt-block+*/
33839                               
33840                               break;
33841                             case 2: 
33842                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33843                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33844                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33845                                       /* index at 16 */ && 
33846                                 (MATCH_w_8_16 >> 3 & 0x7) 
33847                                       /* index at 16 */ < 8)) 
33848                                 goto MATCH_label_c704;  /*opt-block+*/
33849                               else 
33850                                 goto MATCH_label_c705;  /*opt-block+*/
33851                               
33852                               break;
33853                             case 3: 
33854                               goto MATCH_label_c702; break;
33855                             default: assert(0);
33856                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33857                         break;
33858                       case 1: 
33859                         
33860                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33861                             case 0: 
33862                               
33863                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33864                                   case 0: case 1: case 2: case 3: case 6: 
33865                                   case 7: 
33866                                     goto MATCH_label_c706; break;
33867                                   case 4: 
33868                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33869                                     if ((MATCH_w_8_16 & 0x7) 
33870                                             /* base at 16 */ == 5 && 
33871                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33872                                             /* index at 16 */ && 
33873                                       (MATCH_w_8_16 >> 3 & 0x7) 
33874                                             /* index at 16 */ < 8)) 
33875                                       goto MATCH_label_c708;  /*opt-block+*/
33876                                     else 
33877                                       goto MATCH_label_c707;  /*opt-block+*/
33878                                     
33879                                     break;
33880                                   case 5: 
33881                                     goto MATCH_label_c709; break;
33882                                   default: assert(0);
33883                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33884                               break;
33885                             case 1: 
33886                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33887                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33888                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33889                                       /* index at 16 */ && 
33890                                 (MATCH_w_8_16 >> 3 & 0x7) 
33891                                       /* index at 16 */ < 8)) { 
33892                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33893                                 nextPC = 4 + MATCH_p; 
33894                                 
33895 #line 722 "frontend/machine/pentium/decoder.m"
33896                                 
33897 
33898                                         stmts = instantiate(pc,  "RORB.Ev.CLod", DIS_EADDR32);
33899 
33900                                 
33901 
33902                                 
33903                                 
33904                                 
33905                               } /*opt-block*//*opt-block+*/
33906                               else 
33907                                 goto MATCH_label_c707;  /*opt-block+*/
33908                               
33909                               break;
33910                             case 2: 
33911                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33912                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33913                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33914                                       /* index at 16 */ && 
33915                                 (MATCH_w_8_16 >> 3 & 0x7) 
33916                                       /* index at 16 */ < 8)) 
33917                                 goto MATCH_label_c708;  /*opt-block+*/
33918                               else 
33919                                 goto MATCH_label_c709;  /*opt-block+*/
33920                               
33921                               break;
33922                             case 3: 
33923                               goto MATCH_label_c706; break;
33924                             default: assert(0);
33925                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33926                         break;
33927                       case 2: 
33928                         
33929                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33930                             case 0: 
33931                               
33932                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33933                                   case 0: case 1: case 2: case 3: case 6: 
33934                                   case 7: 
33935                                     goto MATCH_label_c710; break;
33936                                   case 4: 
33937                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33938                                     if ((MATCH_w_8_16 & 0x7) 
33939                                             /* base at 16 */ == 5 && 
33940                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33941                                             /* index at 16 */ && 
33942                                       (MATCH_w_8_16 >> 3 & 0x7) 
33943                                             /* index at 16 */ < 8)) 
33944                                       goto MATCH_label_c712;  /*opt-block+*/
33945                                     else 
33946                                       goto MATCH_label_c711;  /*opt-block+*/
33947                                     
33948                                     break;
33949                                   case 5: 
33950                                     goto MATCH_label_c713; break;
33951                                   default: assert(0);
33952                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33953                               break;
33954                             case 1: 
33955                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33956                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33957                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33958                                       /* index at 16 */ && 
33959                                 (MATCH_w_8_16 >> 3 & 0x7) 
33960                                       /* index at 16 */ < 8)) { 
33961                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33962                                 nextPC = 4 + MATCH_p; 
33963                                 
33964 #line 710 "frontend/machine/pentium/decoder.m"
33965                                 
33966 
33967                                         stmts = instantiate(pc,  "RCLB.Ev.CLod", DIS_EADDR32);
33968 
33969                                 
33970 
33971                                 
33972                                 
33973                                 
33974                               } /*opt-block*//*opt-block+*/
33975                               else 
33976                                 goto MATCH_label_c711;  /*opt-block+*/
33977                               
33978                               break;
33979                             case 2: 
33980                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33981                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33982                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33983                                       /* index at 16 */ && 
33984                                 (MATCH_w_8_16 >> 3 & 0x7) 
33985                                       /* index at 16 */ < 8)) 
33986                                 goto MATCH_label_c712;  /*opt-block+*/
33987                               else 
33988                                 goto MATCH_label_c713;  /*opt-block+*/
33989                               
33990                               break;
33991                             case 3: 
33992                               goto MATCH_label_c710; break;
33993                             default: assert(0);
33994                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33995                         break;
33996                       case 3: 
33997                         
33998                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33999                             case 0: 
34000                               
34001                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
34002                                   case 0: case 1: case 2: case 3: case 6: 
34003                                   case 7: 
34004                                     goto MATCH_label_c714; break;
34005                                   case 4: 
34006                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
34007                                     if ((MATCH_w_8_16 & 0x7) 
34008                                             /* base at 16 */ == 5 && 
34009                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
34010                                             /* index at 16 */ && 
34011                                       (MATCH_w_8_16 >> 3 & 0x7) 
34012                                             /* index at 16 */ < 8)) 
34013                                       goto MATCH_label_c716;  /*opt-block+*/
34014                                     else 
34015                                       goto MATCH_label_c715;  /*opt-block+*/
34016                                     
34017                                     break;
34018                                   case 5: 
34019                                     goto MATCH_label_c717; break;
34020                                   default: assert(0);
34021                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
34022                               break;
34023                             case 1: 
34024                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
34025                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
34026                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
34027                                       /* index at 16 */ && 
34028                                 (MATCH_w_8_16 >> 3 & 0x7) 
34029                                       /* index at 16 */ < 8)) { 
34030                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
34031                                 nextPC = 4 + MATCH_p; 
34032                                 
34033 #line 698 "frontend/machine/pentium/decoder.m"
34034                                 
34035 
34036                                         stmts = instantiate(pc,  "RCRB.Ev.CLod", DIS_EADDR32);
34037 
34038                                 
34039 
34040                                 
34041                                 
34042                                 
34043                               } /*opt-block*//*opt-block+*/
34044                               else 
34045                                 goto MATCH_label_c715;  /*opt-block+*/
34046                               
34047                               break;
34048                             case 2: 
34049                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
34050                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
34051                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
34052                                       /* index at 16 */ && 
34053                                 (MATCH_w_8_16 >> 3 & 0x7) 
34054                                       /* index at 16 */ < 8)) 
34055                                 goto MATCH_label_c716;  /*opt-block+*/
34056                               else 
34057                                 goto MATCH_label_c717;  /*opt-block+*/
34058                               
34059                               break;
34060                             case 3: 
34061                               goto MATCH_label_c714; break;
34062                             default: assert(0);
34063                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
34064                         break;
34065                       case 4: 
34066                         
34067                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
34068                             case 0: 
34069                               
34070                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
34071                                   case 0: case 1: case 2: case 3: case 6: 
34072                                   case 7: 
34073                                     goto MATCH_label_c718; break;
34074                                   case 4: 
34075                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
34076                                     if ((MATCH_w_8_16 & 0x7) 
34077                                             /* base at 16 */ == 5 && 
34078                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
34079                                             /* index at 16 */ && 
34080                                       (MATCH_w_8_16 >> 3 & 0x7) 
34081                                             /* index at 16 */ < 8)) 
34082                                       goto MATCH_label_c720;  /*opt-block+*/
34083                                     else 
34084                                       goto MATCH_label_c719;  /*opt-block+*/
34085                                     
34086                                     break;
34087                                   case 5: 
34088                                     goto MATCH_label_c721; break;
34089                                   default: assert(0);
34090                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
34091                               break;
34092                             case 1: 
34093                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
34094                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
34095                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
34096                                       /* index at 16 */ && 
34097                                 (MATCH_w_8_16 >> 3 & 0x7) 
34098                                       /* index at 16 */ < 8)) { 
34099                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
34100                                 nextPC = 4 + MATCH_p; 
34101                                 
34102 #line 686 "frontend/machine/pentium/decoder.m"
34103                                 
34104 
34105                                         stmts = instantiate(pc,  "SHLSALB.Ev.CLod", DIS_EADDR32);
34106 
34107                                 
34108 
34109                                 
34110                                 
34111                                 
34112                               } /*opt-block*//*opt-block+*/
34113                               else 
34114                                 goto MATCH_label_c719;  /*opt-block+*/
34115                               
34116                               break;
34117                             case 2: 
34118                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
34119                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
34120                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
34121                                       /* index at 16 */ && 
34122                                 (MATCH_w_8_16 >> 3 & 0x7) 
34123                                       /* index at 16 */ < 8)) 
34124                                 goto MATCH_label_c720;  /*opt-block+*/
34125                               else 
34126                                 goto MATCH_label_c721;  /*opt-block+*/
34127                               
34128                               break;
34129                             case 3: 
34130                               goto MATCH_label_c718; break;
34131                             default: assert(0);
34132                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
34133                         break;
34134                       case 5: 
34135                         
34136                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
34137                             case 0: 
34138                               
34139                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
34140                                   case 0: case 1: case 2: case 3: case 6: 
34141                                   case 7: 
34142                                     goto MATCH_label_c722; break;
34143                                   case 4: 
34144                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
34145                                     if ((MATCH_w_8_16 & 0x7) 
34146                                             /* base at 16 */ == 5 && 
34147                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
34148                                             /* index at 16 */ && 
34149                                       (MATCH_w_8_16 >> 3 & 0x7) 
34150                                             /* index at 16 */ < 8)) 
34151                                       goto MATCH_label_c724;  /*opt-block+*/
34152                                     else 
34153                                       goto MATCH_label_c723;  /*opt-block+*/
34154                                     
34155                                     break;
34156                                   case 5: 
34157                                     goto MATCH_label_c725; break;
34158                                   default: assert(0);
34159                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
34160                               break;
34161                             case 1: 
34162                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
34163                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
34164                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
34165                                       /* index at 16 */ && 
34166                                 (MATCH_w_8_16 >> 3 & 0x7) 
34167                                       /* index at 16 */ < 8)) { 
34168                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
34169                                 nextPC = 4 + MATCH_p; 
34170                                 
34171 #line 674 "frontend/machine/pentium/decoder.m"
34172                                 
34173 
34174                                         stmts = instantiate(pc,  "SHRB.Ev.CLod", DIS_EADDR32);
34175 
34176                                 
34177 
34178                                 
34179                                 
34180                                 
34181                               } /*opt-block*//*opt-block+*/
34182                               else 
34183                                 goto MATCH_label_c723;  /*opt-block+*/
34184                               
34185                               break;
34186                             case 2: 
34187                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
34188                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
34189                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
34190                                       /* index at 16 */ && 
34191                                 (MATCH_w_8_16 >> 3 & 0x7) 
34192                                       /* index at 16 */ < 8)) 
34193                                 goto MATCH_label_c724;  /*opt-block+*/
34194                               else 
34195                                 goto MATCH_label_c725;  /*opt-block+*/
34196                               
34197                               break;
34198                             case 3: 
34199                               goto MATCH_label_c722; break;
34200                             default: assert(0);
34201                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
34202                         break;
34203                       case 6: 
34204                         goto MATCH_label_c64; break;
34205                       case 7: 
34206                         
34207                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
34208                             case 0: 
34209                               
34210                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
34211                                   case 0: case 1: case 2: case 3: case 6: 
34212                                   case 7: 
34213                                     goto MATCH_label_c726; break;
34214                                   case 4: 
34215                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
34216                                     if ((MATCH_w_8_16 & 0x7) 
34217                                             /* base at 16 */ == 5 && 
34218                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
34219                                             /* index at 16 */ && 
34220                                       (MATCH_w_8_16 >> 3 & 0x7) 
34221                                             /* index at 16 */ < 8)) 
34222                                       goto MATCH_label_c728;  /*opt-block+*/
34223                                     else 
34224                                       goto MATCH_label_c727;  /*opt-block+*/
34225                                     
34226                                     break;
34227                                   case 5: 
34228                                     goto MATCH_label_c729; break;
34229                                   default: assert(0);
34230                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
34231                               break;
34232                             case 1: 
34233                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
34234                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
34235                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
34236                                       /* index at 16 */ && 
34237                                 (MATCH_w_8_16 >> 3 & 0x7) 
34238                                       /* index at 16 */ < 8)) { 
34239                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
34240                                 nextPC = 4 + MATCH_p; 
34241                                 
34242 #line 662 "frontend/machine/pentium/decoder.m"
34243                                 
34244 
34245                                         stmts = instantiate(pc,  "SARB.Ev.CLod", DIS_EADDR32);
34246 
34247                                 
34248 
34249                                 
34250                                 
34251                                 
34252                               } /*opt-block*//*opt-block+*/
34253                               else 
34254                                 goto MATCH_label_c727;  /*opt-block+*/
34255                               
34256                               break;
34257                             case 2: 
34258                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
34259                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
34260                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
34261                                       /* index at 16 */ && 
34262                                 (MATCH_w_8_16 >> 3 & 0x7) 
34263                                       /* index at 16 */ < 8)) 
34264                                 goto MATCH_label_c728;  /*opt-block+*/
34265                               else 
34266                                 goto MATCH_label_c729;  /*opt-block+*/
34267                               
34268                               break;
34269                             case 3: 
34270                               goto MATCH_label_c726; break;
34271                             default: assert(0);
34272                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
34273                         break;
34274                       default: assert(0);
34275                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
34276                   
34277                   break;
34278                 case 4: case 5: case 6: 
34279                   goto MATCH_label_c64; break;
34280                 case 7: 
34281                   nextPC = 1 + MATCH_p; 
34282                   
34283 #line 315 "frontend/machine/pentium/decoder.m"
34284                   
34285 
34286                         stmts = instantiate(pc,  "XLATB");
34287 
34288                   
34289 
34290                   
34291                   
34292                   
34293                   
34294                   break;
34295                 default: assert(0);
34296               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
34297             break;
34298           case 14: 
34299             
34300               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
34301                 case 0: 
34302                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
34303                   { 
34304                     unsigned relocd = 
34305                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
34306                                   8) + addressToPC(MATCH_p);
34307                     nextPC = 2 + MATCH_p; 
34308                     
34309 #line 1052 "frontend/machine/pentium/decoder.m"
34310                     
34311 
34312                             stmts = instantiate(pc,  "LOOPNE", dis_Num(relocd - hostPC - 2));
34313 
34314                     
34315 
34316                     
34317                     
34318                     
34319                   }
34320                   
34321                   break;
34322                 case 1: 
34323                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
34324                   { 
34325                     unsigned relocd = 
34326                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
34327                                   8) + addressToPC(MATCH_p);
34328                     nextPC = 2 + MATCH_p; 
34329                     
34330 #line 1055 "frontend/machine/pentium/decoder.m"
34331                     
34332 
34333                             stmts = instantiate(pc,  "LOOPE", dis_Num(relocd-hostPC-2));
34334 
34335                     
34336 
34337                     
34338                     
34339                     
34340                   }
34341                   
34342                   break;
34343                 case 2: 
34344                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
34345                   { 
34346                     unsigned relocd = 
34347                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
34348                                   8) + addressToPC(MATCH_p);
34349                     nextPC = 2 + MATCH_p; 
34350                     
34351 #line 1058 "frontend/machine/pentium/decoder.m"
34352                     
34353 
34354                             stmts = instantiate(pc,  "LOOP", dis_Num(relocd-hostPC-2));
34355 
34356                     
34357 
34358                     
34359                     
34360                     
34361                   }
34362                   
34363                   break;
34364                 case 3: case 4: case 5: case 6: case 7: 
34365                   goto MATCH_label_c64; break;
34366                 default: assert(0);
34367               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
34368             break;
34369           case 15: 
34370             
34371               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
34372                 case 0: case 1: case 4: 
34373                   goto MATCH_label_c64; break;
34374                 case 2: 
34375                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
34376                   
34377                     switch((MATCH_w_8_8 >> 4 & 0xf) /* row at 8 */) {
34378                       case 0: case 1: case 2: case 3: case 4: case 5: case 7: 
34379                       case 8: case 9: case 11: case 12: case 13: case 14: 
34380                       case 15: 
34381                         goto MATCH_label_c64; break;
34382                       case 6: 
34383                         if ((MATCH_w_8_8 & 0x7) /* col at 8 */ == 6) 
34384                           if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) 
34385                             goto MATCH_label_c64;  /*opt-block+*/
34386                           else { 
34387                             MATCH_w_8_16 = getByte(2 + MATCH_p); 
34388                             
34389                               switch((MATCH_w_8_16 & 0x7) /* col at 16 */) {
34390                                 case 0: case 1: case 2: case 4: case 6: 
34391                                   goto MATCH_label_c64; break;
34392                                 case 3: 
34393                                   if ((MATCH_w_8_16 >> 4 & 0xf) 
34394                                           /* row at 16 */ == 10 && 
34395                                     (MATCH_w_8_16 >> 3 & 0x1) 
34396                                           /* page at 16 */ == 1) { 
34397                                     MATCH_name = 
34398                                       MATCH_name_page_1[(MATCH_w_8_16 >> 3 & 0x1) 
34399                                           /* page at 16 */]; 
34400                                     { 
34401                                       char *name = MATCH_name;
34402                                       nextPC = 3 + MATCH_p; 
34403                                       
34404 #line 590 "frontend/machine/pentium/decoder.m"
34405                                       
34406 
34407                                             stmts = instantiate(pc,  name);
34408 
34409                                       
34410 
34411                                       
34412                                       
34413                                       
34414                                     }
34415                                     
34416                                   } /*opt-block*/
34417                                   else 
34418                                     goto MATCH_label_c64;  /*opt-block+*/
34419                                   
34420                                   break;
34421                                 case 5: 
34422                                   if ((MATCH_w_8_16 >> 4 & 0xf) 
34423                                           /* row at 16 */ == 10) 
34424                                     if ((MATCH_w_8_16 >> 3 & 0x1) 
34425                                             /* page at 16 */ == 1) { 
34426                                       MATCH_name = 
34427                                         MATCH_name_page_2[(MATCH_w_8_16 >> 3 & 0x1) 
34428                                             /* page at 16 */]; 
34429                                       { 
34430                                         char *name = MATCH_name;
34431                                         nextPC = 3 + MATCH_p; 
34432                                         
34433 #line 563 "frontend/machine/pentium/decoder.m"
34434                                         
34435 
34436                                                 stmts = instantiate(pc,  name);
34437 
34438                                         
34439 
34440                                         
34441                                         
34442                                         
34443                                       }
34444                                       
34445                                     } /*opt-block*/
34446                                     else { 
34447                                       MATCH_name = 
34448                                         MATCH_name_page_1[(MATCH_w_8_16 >> 3 & 0x1) 
34449                                             /* page at 16 */]; 
34450                                       { 
34451                                         char *name = MATCH_name;
34452                                         nextPC = 3 + MATCH_p; 
34453                                         
34454 #line 572 "frontend/machine/pentium/decoder.m"
34455                                         
34456 
34457                                                 stmts = instantiate(pc,  name);
34458 
34459                                         
34460 
34461                                         
34462                                         
34463                                         
34464                                       }
34465                                       
34466                                     } /*opt-block*/ /*opt-block+*/
34467                                   else 
34468                                     goto MATCH_label_c64;  /*opt-block+*/
34469                                   break;
34470                                 case 7: 
34471                                   if ((MATCH_w_8_16 >> 4 & 0xf) 
34472                                           /* row at 16 */ == 10) 
34473                                     if ((MATCH_w_8_16 >> 3 & 0x1) 
34474                                             /* page at 16 */ == 1) { 
34475                                       MATCH_name = 
34476                                         MATCH_name_page_3[(MATCH_w_8_16 >> 3 & 0x1) 
34477                                             /* page at 16 */]; 
34478                                       { 
34479                                         char *name = MATCH_name;
34480                                         nextPC = 3 + MATCH_p; 
34481                                         
34482 #line 581 "frontend/machine/pentium/decoder.m"
34483                                         
34484 
34485                                                 stmts = instantiate(pc,  name);
34486 
34487                                         
34488 
34489                                         
34490                                         
34491                                         
34492                                       }
34493                                       
34494                                     } /*opt-block*/
34495                                     else { 
34496                                       MATCH_name = 
34497                                         MATCH_name_page_2[(MATCH_w_8_16 >> 3 & 0x1) 
34498                                             /* page at 16 */]; 
34499                                       { 
34500                                         char *name = MATCH_name;
34501                                         nextPC = 3 + MATCH_p; 
34502                                         
34503 #line 554 "frontend/machine/pentium/decoder.m"
34504                                         
34505 
34506                                                 stmts = instantiate(pc,  name);
34507 
34508                                         
34509 
34510                                         
34511                                         
34512                                         
34513                                       }
34514                                       
34515                                     } /*opt-block*/ /*opt-block+*/
34516                                   else 
34517                                     goto MATCH_label_c64;  /*opt-block+*/
34518                                   break;
34519                                 default: assert(0);
34520                               } /* (MATCH_w_8_16 & 0x7) -- col at 16 --*/ 
34521                             
34522                           } /*opt-block*/ 
34523                         else 
34524                           goto MATCH_label_c64;  /*opt-block+*/
34525                         break;
34526                       case 10: 
34527                         
34528                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
34529                             case 0: case 1: 
34530                               goto MATCH_label_c64; break;
34531                             case 2: 
34532                               if ((MATCH_w_8_8 >> 3 & 0x1) 
34533                                       /* page at 8 */ == 1) { 
34534                                 MATCH_name = 
34535                                   MATCH_name_page_4[(MATCH_w_8_8 >> 3 & 0x1) 
34536                                       /* page at 8 */]; 
34537                                 { 
34538                                   char *name = MATCH_name;
34539                                   nextPC = 2 + MATCH_p; 
34540                                   
34541 #line 587 "frontend/machine/pentium/decoder.m"
34542                                   
34543 
34544                                         stmts = instantiate(pc,  name);
34545 
34546                                   
34547 
34548                                   
34549                                   
34550                                   
34551                                 }
34552                                 
34553                               } /*opt-block*/
34554                               else 
34555                                 goto MATCH_label_c64;  /*opt-block+*/
34556                               
34557                               break;
34558                             case 3: 
34559                               if ((MATCH_w_8_8 >> 3 & 0x1) 
34560                                       /* page at 8 */ == 1) { 
34561                                 MATCH_name = 
34562                                   MATCH_name_page_5[(MATCH_w_8_8 >> 3 & 0x1) 
34563                                       /* page at 8 */]; 
34564                                 { 
34565                                   char *name = MATCH_name;
34566                                   nextPC = 2 + MATCH_p; 
34567                                   
34568 #line 593 "frontend/machine/pentium/decoder.m"
34569                                   
34570 
34571                                         stmts = instantiate(pc,  name);
34572 
34573                                   
34574 
34575                                   
34576                                   
34577                                   
34578                                 }
34579                                 
34580                               } /*opt-block*/
34581                               else 
34582                                 goto MATCH_label_c64;  /*opt-block+*/
34583                               
34584                               break;
34585                             case 4: 
34586                               if ((MATCH_w_8_8 >> 3 & 0x1) 
34587                                       /* page at 8 */ == 1) { 
34588                                 MATCH_name = 
34589                                   MATCH_name_page_6[(MATCH_w_8_8 >> 3 & 0x1) 
34590                                       /* page at 8 */]; 
34591                                 { 
34592                                   char *name = MATCH_name;
34593                                   nextPC = 2 + MATCH_p; 
34594                                   
34595 #line 560 "frontend/machine/pentium/decoder.m"
34596                                   
34597 
34598                                         stmts = instantiate(pc,  name);
34599 
34600                                   
34601 
34602                                   
34603                                   
34604                                   
34605                                 }
34606                                 
34607                               } /*opt-block*/
34608                               else { 
34609                                 MATCH_name = 
34610                                   MATCH_name_page_0[(MATCH_w_8_8 >> 3 & 0x1) 
34611                                       /* page at 8 */]; 
34612                                 { 
34613                                   char *name = MATCH_name;
34614                                   nextPC = 2 + MATCH_p; 
34615                                   
34616 #line 569 "frontend/machine/pentium/decoder.m"
34617                                   
34618 
34619                                         stmts = instantiate(pc,  name);
34620 
34621                                   
34622 
34623                                   
34624                                   
34625                                   
34626                                 }
34627                                 
34628                               } /*opt-block*/
34629                               
34630                               break;
34631                             case 5: 
34632                               if ((MATCH_w_8_8 >> 3 & 0x1) 
34633                                       /* page at 8 */ == 1) { 
34634                                 MATCH_name = 
34635                                   MATCH_name_page_7[(MATCH_w_8_8 >> 3 & 0x1) 
34636                                       /* page at 8 */]; 
34637                                 { 
34638                                   char *name = MATCH_name;
34639                                   nextPC = 2 + MATCH_p; 
34640                                   
34641 #line 566 "frontend/machine/pentium/decoder.m"
34642                                   
34643 
34644                                         stmts = instantiate(pc,  name);
34645 
34646                                   
34647 
34648                                   
34649                                   
34650                                   
34651                                 }
34652                                 
34653                               } /*opt-block*/
34654                               else { 
34655                                 MATCH_name = 
34656                                   MATCH_name_page_4[(MATCH_w_8_8 >> 3 & 0x1) 
34657                                       /* page at 8 */]; 
34658                                 { 
34659                                   char *name = MATCH_name;
34660                                   nextPC = 2 + MATCH_p; 
34661                                   
34662 #line 575 "frontend/machine/pentium/decoder.m"
34663                                   
34664 
34665                                         stmts = instantiate(pc,  name);
34666 
34667                                   
34668 
34669                                   
34670                                   
34671                                   
34672                                 }
34673                                 
34674                               } /*opt-block*/
34675                               
34676                               break;
34677                             case 6: 
34678                               if ((MATCH_w_8_8 >> 3 & 0x1) 
34679                                       /* page at 8 */ == 1) { 
34680                                 MATCH_name = 
34681                                   MATCH_name_page_8[(MATCH_w_8_8 >> 3 & 0x1) 
34682                                       /* page at 8 */]; 
34683                                 { 
34684                                   char *name = MATCH_name;
34685                                   nextPC = 2 + MATCH_p; 
34686                                   
34687 #line 578 "frontend/machine/pentium/decoder.m"
34688                                   
34689 
34690                                         stmts = instantiate(pc,  name);
34691 
34692                                   
34693 
34694                                   
34695                                   
34696                                   
34697                                 }
34698                                 
34699                               } /*opt-block*/
34700                               else { 
34701                                 MATCH_name = 
34702                                   MATCH_name_page_5[(MATCH_w_8_8 >> 3 & 0x1) 
34703                                       /* page at 8 */]; 
34704                                 { 
34705                                   char *name = MATCH_name;
34706                                   nextPC = 2 + MATCH_p; 
34707                                   
34708 #line 551 "frontend/machine/pentium/decoder.m"
34709                                   
34710 
34711                                         stmts = instantiate(pc,  name);
34712 
34713                                   
34714 
34715                                   
34716                                   
34717                                   
34718                                 }
34719                                 
34720                               } /*opt-block*/
34721                               
34722                               break;
34723                             case 7: 
34724                               if ((MATCH_w_8_8 >> 3 & 0x1) 
34725                                       /* page at 8 */ == 1) { 
34726                                 MATCH_name = 
34727                                   MATCH_name_page_9[(MATCH_w_8_8 >> 3 & 0x1) 
34728                                       /* page at 8 */]; 
34729                                 { 
34730                                   char *name = MATCH_name;
34731                                   nextPC = 2 + MATCH_p; 
34732                                   
34733 #line 584 "frontend/machine/pentium/decoder.m"
34734                                   
34735 
34736                                         stmts = instantiate(pc,  name);
34737 
34738                                   
34739 
34740                                   
34741                                   
34742                                   
34743                                 }
34744                                 
34745                               } /*opt-block*/
34746                               else { 
34747                                 MATCH_name = 
34748                                   MATCH_name_page_6[(MATCH_w_8_8 >> 3 & 0x1) 
34749                                       /* page at 8 */]; 
34750                                 { 
34751                                   char *name = MATCH_name;
34752                                   nextPC = 2 + MATCH_p; 
34753                                   
34754 #line 557 "frontend/machine/pentium/decoder.m"
34755                                   
34756 
34757                                         stmts = instantiate(pc,  name);
34758 
34759                                   
34760 
34761                                   
34762                                   
34763                                   
34764                                 }
34765                                 
34766                               } /*opt-block*/
34767                               
34768                               break;
34769                             default: assert(0);
34770                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
34771                         break;
34772                       default: assert(0);
34773                     } /* (MATCH_w_8_8 >> 4 & 0xf) -- row at 8 --*/ 
34774                   
34775                   break;
34776                 case 3: 
34777                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
34778                   
34779                     switch((MATCH_w_8_8 >> 4 & 0xf) /* row at 8 */) {
34780                       case 0: case 1: case 2: case 3: case 4: case 5: case 7: 
34781                       case 8: case 9: case 11: case 12: case 13: case 14: 
34782                       case 15: 
34783                         goto MATCH_label_c64; break;
34784                       case 6: 
34785                         if ((MATCH_w_8_8 & 0x7) /* col at 8 */ == 6) 
34786                           if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) 
34787                             goto MATCH_label_c64;  /*opt-block+*/
34788                           else { 
34789                             MATCH_w_8_16 = getByte(2 + MATCH_p); 
34790                             
34791                               switch((MATCH_w_8_16 & 0x7) /* col at 16 */) {
34792                                 case 0: case 1: case 2: case 4: case 6: 
34793                                   goto MATCH_label_c64; break;
34794                                 case 3: 
34795                                   if ((MATCH_w_8_16 >> 4 & 0xf) 
34796                                           /* row at 16 */ == 10 && 
34797                                     (MATCH_w_8_16 >> 3 & 0x1) 
34798                                           /* page at 16 */ == 1) { 
34799                                     MATCH_name = 
34800                                       MATCH_name_page_10[(MATCH_w_8_16 >> 3 & 0x1) 
34801                                           /* page at 16 */]; 
34802                                     { 
34803                                       char *name = MATCH_name;
34804                                       nextPC = 3 + MATCH_p; 
34805                                       
34806 #line 545 "frontend/machine/pentium/decoder.m"
34807                                       
34808 
34809                                             stmts = instantiate(pc,  name);
34810 
34811                                       
34812 
34813                                       
34814                                       
34815                                       
34816                                     }
34817                                     
34818                                   } /*opt-block*/
34819                                   else 
34820                                     goto MATCH_label_c64;  /*opt-block+*/
34821                                   
34822                                   break;
34823                                 case 5: 
34824                                   if ((MATCH_w_8_16 >> 4 & 0xf) 
34825                                           /* row at 16 */ == 10) 
34826                                     if ((MATCH_w_8_16 >> 3 & 0x1) 
34827                                             /* page at 16 */ == 1) { 
34828                                       MATCH_name = "REP.LODSvow"; 
34829                                       { 
34830                                         char *name = MATCH_name;
34831                                         nextPC = 3 + MATCH_p; 
34832                                         
34833 #line 518 "frontend/machine/pentium/decoder.m"
34834                                         
34835 
34836                                                 stmts = instantiate(pc,  name);
34837 
34838                                         
34839 
34840                                         
34841                                         
34842                                         
34843                                       }
34844                                       
34845                                     } /*opt-block*/
34846                                     else { 
34847                                       MATCH_name = 
34848                                         MATCH_name_page_3[(MATCH_w_8_16 >> 3 & 0x1) 
34849                                             /* page at 16 */]; 
34850                                       { 
34851                                         char *name = MATCH_name;
34852                                         nextPC = 3 + MATCH_p; 
34853                                         
34854 #line 527 "frontend/machine/pentium/decoder.m"
34855                                         
34856 
34857                                                 stmts = instantiate(pc,  name);
34858 
34859                                         
34860 
34861                                         
34862                                         
34863                                         
34864                                       }
34865                                       
34866                                     } /*opt-block*/ /*opt-block+*/
34867                                   else 
34868                                     goto MATCH_label_c64;  /*opt-block+*/
34869                                   break;
34870                                 case 7: 
34871                                   if ((MATCH_w_8_16 >> 4 & 0xf) 
34872                                           /* row at 16 */ == 10) 
34873                                     if ((MATCH_w_8_16 >> 3 & 0x1) 
34874                                             /* page at 16 */ == 1) { 
34875                                       MATCH_name = "REP.SCASvow"; 
34876                                       { 
34877                                         char *name = MATCH_name;
34878                                         nextPC = 3 + MATCH_p; 
34879                                         
34880 #line 536 "frontend/machine/pentium/decoder.m"
34881                                         
34882 
34883                                                 stmts = instantiate(pc,  name);
34884 
34885                                         
34886 
34887                                         
34888                                         
34889                                         
34890                                       }
34891                                       
34892                                     } /*opt-block*/
34893                                     else { 
34894                                       MATCH_name = 
34895                                         MATCH_name_page_10[(MATCH_w_8_16 >> 3 & 0x1) 
34896                                             /* page at 16 */]; 
34897                                       { 
34898                                         char *name = MATCH_name;
34899                                         nextPC = 3 + MATCH_p; 
34900                                         
34901 #line 509 "frontend/machine/pentium/decoder.m"
34902                                         
34903 
34904                                                 stmts = instantiate(pc,  name);
34905 
34906                                         
34907 
34908                                         
34909                                         
34910                                         
34911                                       }
34912                                       
34913                                     } /*opt-block*/ /*opt-block+*/
34914                                   else 
34915                                     goto MATCH_label_c64;  /*opt-block+*/
34916                                   break;
34917                                 default: assert(0);
34918                               } /* (MATCH_w_8_16 & 0x7) -- col at 16 --*/ 
34919                             
34920                           } /*opt-block*/ 
34921                         else 
34922                           goto MATCH_label_c64;  /*opt-block+*/
34923                         break;
34924                       case 10: 
34925                         
34926                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
34927                             case 0: case 1: 
34928                               goto MATCH_label_c64; break;
34929                             case 2: 
34930                               if ((MATCH_w_8_8 >> 3 & 0x1) 
34931                                       /* page at 8 */ == 1) { 
34932                                 MATCH_name = 
34933                                   MATCH_name_page_13[(MATCH_w_8_8 >> 3 & 0x1) 
34934                                       /* page at 8 */]; 
34935                                 { 
34936                                   char *name = MATCH_name;
34937                                   nextPC = 2 + MATCH_p; 
34938                                   
34939 #line 542 "frontend/machine/pentium/decoder.m"
34940                                   
34941 
34942                                         stmts = instantiate(pc,  name);
34943 
34944                                   
34945 
34946                                   
34947                                   
34948                                   
34949                                 }
34950                                 
34951                               } /*opt-block*/
34952                               else 
34953                                 goto MATCH_label_c64;  /*opt-block+*/
34954                               
34955                               break;
34956                             case 3: 
34957                               if ((MATCH_w_8_8 >> 3 & 0x1) 
34958                                       /* page at 8 */ == 1) { 
34959                                 MATCH_name = "REP.STOSvod"; 
34960                                 { 
34961                                   char *name = MATCH_name;
34962                                   nextPC = 2 + MATCH_p; 
34963                                   
34964 #line 548 "frontend/machine/pentium/decoder.m"
34965                                   
34966 
34967                                         stmts = instantiate(pc,  name);
34968 
34969                                   
34970 
34971                                   
34972                                   
34973                                   
34974                                 }
34975                                 
34976                               } /*opt-block*/
34977                               else 
34978                                 goto MATCH_label_c64;  /*opt-block+*/
34979                               
34980                               break;
34981                             case 4: 
34982                               if ((MATCH_w_8_8 >> 3 & 0x1) 
34983                                       /* page at 8 */ == 1) { 
34984                                 MATCH_name = "REP.LODSB"; 
34985                                 { 
34986                                   char *name = MATCH_name;
34987                                   nextPC = 2 + MATCH_p; 
34988                                   
34989 #line 515 "frontend/machine/pentium/decoder.m"
34990                                   
34991 
34992                                         stmts = instantiate(pc,  name);
34993 
34994                                   
34995 
34996                                   
34997                                   
34998                                   
34999                                 }
35000                                 
35001                               } /*opt-block*/
35002                               else { 
35003                                 MATCH_name = 
35004                                   MATCH_name_page_7[(MATCH_w_8_8 >> 3 & 0x1) 
35005                                       /* page at 8 */]; 
35006                                 { 
35007                                   char *name = MATCH_name;
35008                                   nextPC = 2 + MATCH_p; 
35009                                   
35010 #line 524 "frontend/machine/pentium/decoder.m"
35011                                   
35012 
35013                                         stmts = instantiate(pc,  name);
35014 
35015                                   
35016 
35017                                   
35018                                   
35019                                   
35020                                 }
35021                                 
35022                               } /*opt-block*/
35023                               
35024                               break;
35025                             case 5: 
35026                               if ((MATCH_w_8_8 >> 3 & 0x1) 
35027                                       /* page at 8 */ == 1) { 
35028                                 MATCH_name = "REP.LODSvod"; 
35029                                 { 
35030                                   char *name = MATCH_name;
35031                                   nextPC = 2 + MATCH_p; 
35032                                   
35033 #line 521 "frontend/machine/pentium/decoder.m"
35034                                   
35035 
35036                                         stmts = instantiate(pc,  name);
35037 
35038                                   
35039 
35040                                   
35041                                   
35042                                   
35043                                 }
35044                                 
35045                               } /*opt-block*/
35046                               else { 
35047                                 MATCH_name = 
35048                                   MATCH_name_page_8[(MATCH_w_8_8 >> 3 & 0x1) 
35049                                       /* page at 8 */]; 
35050                                 { 
35051                                   char *name = MATCH_name;
35052                                   nextPC = 2 + MATCH_p; 
35053                                   
35054 #line 530 "frontend/machine/pentium/decoder.m"
35055                                   
35056 
35057                                         stmts = instantiate(pc,  name);
35058 
35059                                   
35060 
35061                                   
35062                                   
35063                                   
35064                                 }
35065                                 
35066                               } /*opt-block*/
35067                               
35068                               break;
35069                             case 6: 
35070                               if ((MATCH_w_8_8 >> 3 & 0x1) 
35071                                       /* page at 8 */ == 1) { 
35072                                 MATCH_name = "REP.SCASB"; 
35073                                 { 
35074                                   char *name = MATCH_name;
35075                                   nextPC = 2 + MATCH_p; 
35076                                   
35077 #line 533 "frontend/machine/pentium/decoder.m"
35078                                   
35079 
35080                                         stmts = instantiate(pc,  name);
35081 
35082                                   
35083 
35084                                   
35085                                   
35086                                   
35087                                 }
35088                                 
35089                               } /*opt-block*/
35090                               else { 
35091                                 MATCH_name = 
35092                                   MATCH_name_page_9[(MATCH_w_8_8 >> 3 & 0x1) 
35093                                       /* page at 8 */]; 
35094                                 { 
35095                                   char *name = MATCH_name;
35096                                   nextPC = 2 + MATCH_p; 
35097                                   
35098 #line 506 "frontend/machine/pentium/decoder.m"
35099                                   
35100 
35101                                         stmts = instantiate(pc,  name);
35102 
35103                                   
35104 
35105                                   
35106                                   
35107                                   
35108                                 }
35109                                 
35110                               } /*opt-block*/
35111                               
35112                               break;
35113                             case 7: 
35114                               if ((MATCH_w_8_8 >> 3 & 0x1) 
35115                                       /* page at 8 */ == 1) { 
35116                                 MATCH_name = "REP.SCASvod"; 
35117                                 { 
35118                                   char *name = MATCH_name;
35119                                   nextPC = 2 + MATCH_p; 
35120                                   
35121 #line 539 "frontend/machine/pentium/decoder.m"
35122                                   
35123 
35124                                         stmts = instantiate(pc,  name);
35125 
35126                                   
35127 
35128                                   
35129                                   
35130                                   
35131                                 }
35132                                 
35133                               } /*opt-block*/
35134                               else { 
35135                                 MATCH_name = 
35136                                   MATCH_name_page_13[(MATCH_w_8_8 >> 3 & 0x1) 
35137                                       /* page at 8 */]; 
35138                                 { 
35139                                   char *name = MATCH_name;
35140                                   nextPC = 2 + MATCH_p; 
35141                                   
35142 #line 512 "frontend/machine/pentium/decoder.m"
35143                                   
35144 
35145                                         stmts = instantiate(pc,  name);
35146 
35147                                   
35148 
35149                                   
35150                                   
35151                                   
35152                                 }
35153                                 
35154                               } /*opt-block*/
35155                               
35156                               break;
35157                             default: assert(0);
35158                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
35159                         break;
35160                       default: assert(0);
35161                     } /* (MATCH_w_8_8 >> 4 & 0xf) -- row at 8 --*/ 
35162                   
35163                   break;
35164                 case 5: 
35165                   nextPC = 1 + MATCH_p; 
35166                   
35167 #line 1256 "frontend/machine/pentium/decoder.m"
35168                   
35169 
35170                         stmts = instantiate(pc,  "CMC");
35171 
35172                   
35173 
35174                   
35175                   
35176                   
35177                   
35178                   break;
35179                 case 6: 
35180                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
35181                   
35182                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
35183                       case 0: 
35184                         
35185                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
35186                             case 0: 
35187                               
35188                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
35189                                   case 0: case 1: case 2: case 3: case 6: 
35190                                   case 7: 
35191                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
35192                                     goto MATCH_label_c730; 
35193                                     
35194                                     break;
35195                                   case 4: 
35196                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
35197                                     if ((MATCH_w_8_16 & 0x7) 
35198                                             /* base at 16 */ == 5 && 
35199                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35200                                             /* index at 16 */ && 
35201                                       (MATCH_w_8_16 >> 3 & 0x7) 
35202                                             /* index at 16 */ < 8)) { 
35203                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
35204                                       goto MATCH_label_c732; 
35205                                       
35206                                     } /*opt-block*/
35207                                     else { 
35208                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
35209                                       goto MATCH_label_c731; 
35210                                       
35211                                     } /*opt-block*/
35212                                     
35213                                     break;
35214                                   case 5: 
35215                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
35216                                     goto MATCH_label_c733; 
35217                                     
35218                                     break;
35219                                   default: assert(0);
35220                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
35221                               break;
35222                             case 1: 
35223                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35224                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35225                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35226                                       /* index at 16 */ && 
35227                                 (MATCH_w_8_16 >> 3 & 0x7) 
35228                                       /* index at 16 */ < 8)) { 
35229                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
35230                                 { 
35231                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
35232                                   unsigned i8 = 
35233                                     (MATCH_w_8_32 & 0xff) /* i8 at 32 */;
35234                                   nextPC = 5 + MATCH_p; 
35235                                   
35236 #line 393 "frontend/machine/pentium/decoder.m"
35237                                   
35238 
35239                                         stmts = instantiate(pc,  "TEST.Eb.Ib", DIS_EADDR8, DIS_I8);
35240 
35241                                   
35242 
35243                                   
35244                                   
35245                                   
35246                                 }
35247                                 
35248                               } /*opt-block*/
35249                               else { 
35250                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
35251                                 goto MATCH_label_c731; 
35252                                 
35253                               } /*opt-block*/
35254                               
35255                               break;
35256                             case 2: 
35257                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35258                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35259                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35260                                       /* index at 16 */ && 
35261                                 (MATCH_w_8_16 >> 3 & 0x7) 
35262                                       /* index at 16 */ < 8)) { 
35263                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
35264                                 goto MATCH_label_c732; 
35265                                 
35266                               } /*opt-block*/
35267                               else { 
35268                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
35269                                 goto MATCH_label_c733; 
35270                                 
35271                               } /*opt-block*/
35272                               
35273                               break;
35274                             case 3: 
35275                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35276                               goto MATCH_label_c730; 
35277                               
35278                               break;
35279                             default: assert(0);
35280                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
35281                         break;
35282                       case 1: 
35283                         goto MATCH_label_c64; break;
35284                       case 2: 
35285                         
35286                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
35287                             case 0: 
35288                               
35289                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
35290                                   case 0: case 1: case 2: case 3: case 6: 
35291                                   case 7: 
35292                                     goto MATCH_label_c734; break;
35293                                   case 4: 
35294                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
35295                                     if ((MATCH_w_8_16 & 0x7) 
35296                                             /* base at 16 */ == 5 && 
35297                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35298                                             /* index at 16 */ && 
35299                                       (MATCH_w_8_16 >> 3 & 0x7) 
35300                                             /* index at 16 */ < 8)) 
35301                                       goto MATCH_label_c736;  /*opt-block+*/
35302                                     else 
35303                                       goto MATCH_label_c735;  /*opt-block+*/
35304                                     
35305                                     break;
35306                                   case 5: 
35307                                     goto MATCH_label_c737; break;
35308                                   default: assert(0);
35309                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
35310                               break;
35311                             case 1: 
35312                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35313                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35314                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35315                                       /* index at 16 */ && 
35316                                 (MATCH_w_8_16 >> 3 & 0x7) 
35317                                       /* index at 16 */ < 8)) { 
35318                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
35319                                 nextPC = 4 + MATCH_p; 
35320                                 
35321 #line 916 "frontend/machine/pentium/decoder.m"
35322                                 
35323 
35324                                         stmts = instantiate(pc,  "NOTb", DIS_EADDR8);
35325 
35326                                 
35327 
35328                                 
35329                                 
35330                                 
35331                               } /*opt-block*//*opt-block+*/
35332                               else 
35333                                 goto MATCH_label_c735;  /*opt-block+*/
35334                               
35335                               break;
35336                             case 2: 
35337                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35338                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35339                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35340                                       /* index at 16 */ && 
35341                                 (MATCH_w_8_16 >> 3 & 0x7) 
35342                                       /* index at 16 */ < 8)) 
35343                                 goto MATCH_label_c736;  /*opt-block+*/
35344                               else 
35345                                 goto MATCH_label_c737;  /*opt-block+*/
35346                               
35347                               break;
35348                             case 3: 
35349                               goto MATCH_label_c734; break;
35350                             default: assert(0);
35351                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
35352                         break;
35353                       case 3: 
35354                         
35355                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
35356                             case 0: 
35357                               
35358                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
35359                                   case 0: case 1: case 2: case 3: case 6: 
35360                                   case 7: 
35361                                     goto MATCH_label_c738; break;
35362                                   case 4: 
35363                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
35364                                     if ((MATCH_w_8_16 & 0x7) 
35365                                             /* base at 16 */ == 5 && 
35366                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35367                                             /* index at 16 */ && 
35368                                       (MATCH_w_8_16 >> 3 & 0x7) 
35369                                             /* index at 16 */ < 8)) 
35370                                       goto MATCH_label_c740;  /*opt-block+*/
35371                                     else 
35372                                       goto MATCH_label_c739;  /*opt-block+*/
35373                                     
35374                                     break;
35375                                   case 5: 
35376                                     goto MATCH_label_c741; break;
35377                                   default: assert(0);
35378                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
35379                               break;
35380                             case 1: 
35381                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35382                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35383                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35384                                       /* index at 16 */ && 
35385                                 (MATCH_w_8_16 >> 3 & 0x7) 
35386                                       /* index at 16 */ < 8)) { 
35387                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
35388                                 nextPC = 4 + MATCH_p; 
35389                                 
35390 #line 925 "frontend/machine/pentium/decoder.m"
35391                                 
35392 
35393                                         stmts = instantiate(pc,  "NEGb", DIS_EADDR8);
35394 
35395                                 
35396 
35397                                 
35398                                 
35399                                 
35400                               } /*opt-block*//*opt-block+*/
35401                               else 
35402                                 goto MATCH_label_c739;  /*opt-block+*/
35403                               
35404                               break;
35405                             case 2: 
35406                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35407                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35408                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35409                                       /* index at 16 */ && 
35410                                 (MATCH_w_8_16 >> 3 & 0x7) 
35411                                       /* index at 16 */ < 8)) 
35412                                 goto MATCH_label_c740;  /*opt-block+*/
35413                               else 
35414                                 goto MATCH_label_c741;  /*opt-block+*/
35415                               
35416                               break;
35417                             case 3: 
35418                               goto MATCH_label_c738; break;
35419                             default: assert(0);
35420                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
35421                         break;
35422                       case 4: 
35423                         
35424                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
35425                             case 0: 
35426                               
35427                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
35428                                   case 0: case 1: case 2: case 3: case 6: 
35429                                   case 7: 
35430                                     goto MATCH_label_c742; break;
35431                                   case 4: 
35432                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
35433                                     if ((MATCH_w_8_16 & 0x7) 
35434                                             /* base at 16 */ == 5 && 
35435                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35436                                             /* index at 16 */ && 
35437                                       (MATCH_w_8_16 >> 3 & 0x7) 
35438                                             /* index at 16 */ < 8)) 
35439                                       goto MATCH_label_c744;  /*opt-block+*/
35440                                     else 
35441                                       goto MATCH_label_c743;  /*opt-block+*/
35442                                     
35443                                     break;
35444                                   case 5: 
35445                                     goto MATCH_label_c745; break;
35446                                   default: assert(0);
35447                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
35448                               break;
35449                             case 1: 
35450                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35451                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35452                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35453                                       /* index at 16 */ && 
35454                                 (MATCH_w_8_16 >> 3 & 0x7) 
35455                                       /* index at 16 */ < 8)) { 
35456                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
35457                                 nextPC = 4 + MATCH_p; 
35458                                 
35459 #line 934 "frontend/machine/pentium/decoder.m"
35460                                 
35461 
35462                                         stmts = instantiate(pc,  "MUL.AL", DIS_EADDR8);
35463 
35464                                 
35465 
35466                                 
35467                                 
35468                                 
35469                               } /*opt-block*//*opt-block+*/
35470                               else 
35471                                 goto MATCH_label_c743;  /*opt-block+*/
35472                               
35473                               break;
35474                             case 2: 
35475                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35476                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35477                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35478                                       /* index at 16 */ && 
35479                                 (MATCH_w_8_16 >> 3 & 0x7) 
35480                                       /* index at 16 */ < 8)) 
35481                                 goto MATCH_label_c744;  /*opt-block+*/
35482                               else 
35483                                 goto MATCH_label_c745;  /*opt-block+*/
35484                               
35485                               break;
35486                             case 3: 
35487                               goto MATCH_label_c742; break;
35488                             default: assert(0);
35489                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
35490                         break;
35491                       case 5: 
35492                         
35493                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
35494                             case 0: 
35495                               
35496                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
35497                                   case 0: case 1: case 2: case 3: case 6: 
35498                                   case 7: 
35499                                     goto MATCH_label_c746; break;
35500                                   case 4: 
35501                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
35502                                     if ((MATCH_w_8_16 & 0x7) 
35503                                             /* base at 16 */ == 5 && 
35504                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35505                                             /* index at 16 */ && 
35506                                       (MATCH_w_8_16 >> 3 & 0x7) 
35507                                             /* index at 16 */ < 8)) 
35508                                       goto MATCH_label_c748;  /*opt-block+*/
35509                                     else 
35510                                       goto MATCH_label_c747;  /*opt-block+*/
35511                                     
35512                                     break;
35513                                   case 5: 
35514                                     goto MATCH_label_c749; break;
35515                                   default: assert(0);
35516                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
35517                               break;
35518                             case 1: 
35519                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35520                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35521                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35522                                       /* index at 16 */ && 
35523                                 (MATCH_w_8_16 >> 3 & 0x7) 
35524                                       /* index at 16 */ < 8)) { 
35525                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
35526                                 nextPC = 4 + MATCH_p; 
35527                                 
35528 #line 1178 "frontend/machine/pentium/decoder.m"
35529                                 
35530 
35531                                         stmts = instantiate(pc,  "IMULb", DIS_EADDR8);
35532 
35533                                 
35534 
35535                                 
35536                                 
35537                                 
35538                               } /*opt-block*//*opt-block+*/
35539                               else 
35540                                 goto MATCH_label_c747;  /*opt-block+*/
35541                               
35542                               break;
35543                             case 2: 
35544                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35545                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35546                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35547                                       /* index at 16 */ && 
35548                                 (MATCH_w_8_16 >> 3 & 0x7) 
35549                                       /* index at 16 */ < 8)) 
35550                                 goto MATCH_label_c748;  /*opt-block+*/
35551                               else 
35552                                 goto MATCH_label_c749;  /*opt-block+*/
35553                               
35554                               break;
35555                             case 3: 
35556                               goto MATCH_label_c746; break;
35557                             default: assert(0);
35558                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
35559                         break;
35560                       case 6: 
35561                         
35562                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
35563                             case 0: 
35564                               
35565                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
35566                                   case 0: case 1: case 2: case 3: case 6: 
35567                                   case 7: 
35568                                     goto MATCH_label_c750; break;
35569                                   case 4: 
35570                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
35571                                     if ((MATCH_w_8_16 & 0x7) 
35572                                             /* base at 16 */ == 5 && 
35573                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35574                                             /* index at 16 */ && 
35575                                       (MATCH_w_8_16 >> 3 & 0x7) 
35576                                             /* index at 16 */ < 8)) 
35577                                       goto MATCH_label_c752;  /*opt-block+*/
35578                                     else 
35579                                       goto MATCH_label_c751;  /*opt-block+*/
35580                                     
35581                                     break;
35582                                   case 5: 
35583                                     goto MATCH_label_c753; break;
35584                                   default: assert(0);
35585                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
35586                               break;
35587                             case 1: 
35588                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35589                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35590                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35591                                       /* index at 16 */ && 
35592                                 (MATCH_w_8_16 >> 3 & 0x7) 
35593                                       /* index at 16 */ < 8)) { 
35594                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
35595                                 nextPC = 4 + MATCH_p; 
35596                                 
35597 #line 1202 "frontend/machine/pentium/decoder.m"
35598                                 
35599 
35600                                         stmts = instantiate(pc,  "DIVAL", DIS_EADDR8);
35601 
35602                                 
35603 
35604                                 
35605                                 
35606                                 
35607                               } /*opt-block*//*opt-block+*/
35608                               else 
35609                                 goto MATCH_label_c751;  /*opt-block+*/
35610                               
35611                               break;
35612                             case 2: 
35613                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35614                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35615                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35616                                       /* index at 16 */ && 
35617                                 (MATCH_w_8_16 >> 3 & 0x7) 
35618                                       /* index at 16 */ < 8)) 
35619                                 goto MATCH_label_c752;  /*opt-block+*/
35620                               else 
35621                                 goto MATCH_label_c753;  /*opt-block+*/
35622                               
35623                               break;
35624                             case 3: 
35625                               goto MATCH_label_c750; break;
35626                             default: assert(0);
35627                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
35628                         break;
35629                       case 7: 
35630                         
35631                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
35632                             case 0: 
35633                               
35634                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
35635                                   case 0: case 1: case 2: case 3: case 6: 
35636                                   case 7: 
35637                                     goto MATCH_label_c754; break;
35638                                   case 4: 
35639                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
35640                                     if ((MATCH_w_8_16 & 0x7) 
35641                                             /* base at 16 */ == 5 && 
35642                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35643                                             /* index at 16 */ && 
35644                                       (MATCH_w_8_16 >> 3 & 0x7) 
35645                                             /* index at 16 */ < 8)) 
35646                                       goto MATCH_label_c756;  /*opt-block+*/
35647                                     else 
35648                                       goto MATCH_label_c755;  /*opt-block+*/
35649                                     
35650                                     break;
35651                                   case 5: 
35652                                     goto MATCH_label_c757; break;
35653                                   default: assert(0);
35654                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
35655                               break;
35656                             case 1: 
35657                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35658                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35659                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35660                                       /* index at 16 */ && 
35661                                 (MATCH_w_8_16 >> 3 & 0x7) 
35662                                       /* index at 16 */ < 8)) { 
35663                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
35664                                 nextPC = 4 + MATCH_p; 
35665                                 
35666 #line 1187 "frontend/machine/pentium/decoder.m"
35667                                 
35668 
35669                                         stmts = instantiate(pc,  "IDIV", DIS_EADDR8); /* ?? */
35670 
35671                                 
35672 
35673                                 //  | HLT() =>
35674 
35675                                 //      stmts = instantiate(pc,  "HLT");
35676 
35677                                 
35678 
35679                                 
35680                                 
35681                                 
35682                               } /*opt-block*//*opt-block+*/
35683                               else 
35684                                 goto MATCH_label_c755;  /*opt-block+*/
35685                               
35686                               break;
35687                             case 2: 
35688                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35689                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35690                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35691                                       /* index at 16 */ && 
35692                                 (MATCH_w_8_16 >> 3 & 0x7) 
35693                                       /* index at 16 */ < 8)) 
35694                                 goto MATCH_label_c756;  /*opt-block+*/
35695                               else 
35696                                 goto MATCH_label_c757;  /*opt-block+*/
35697                               
35698                               break;
35699                             case 3: 
35700                               goto MATCH_label_c754; break;
35701                             default: assert(0);
35702                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
35703                         break;
35704                       default: assert(0);
35705                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
35706                   
35707                   break;
35708                 case 7: 
35709                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
35710                   
35711                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
35712                       case 0: 
35713                         
35714                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
35715                             case 0: 
35716                               
35717                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
35718                                   case 0: case 1: case 2: case 3: case 6: 
35719                                   case 7: 
35720                                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
35721                                     goto MATCH_label_c758; 
35722                                     
35723                                     break;
35724                                   case 4: 
35725                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
35726                                     if ((MATCH_w_8_16 & 0x7) 
35727                                             /* base at 16 */ == 5 && 
35728                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35729                                             /* index at 16 */ && 
35730                                       (MATCH_w_8_16 >> 3 & 0x7) 
35731                                             /* index at 16 */ < 8)) { 
35732                                       MATCH_w_32_56 = getDword(7 + MATCH_p); 
35733                                       goto MATCH_label_c760; 
35734                                       
35735                                     } /*opt-block*/
35736                                     else { 
35737                                       MATCH_w_32_24 = getDword(3 + MATCH_p); 
35738                                       goto MATCH_label_c759; 
35739                                       
35740                                     } /*opt-block*/
35741                                     
35742                                     break;
35743                                   case 5: 
35744                                     MATCH_w_32_48 = getDword(6 + MATCH_p); 
35745                                     goto MATCH_label_c761; 
35746                                     
35747                                     break;
35748                                   default: assert(0);
35749                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
35750                               break;
35751                             case 1: 
35752                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35753                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35754                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35755                                       /* index at 16 */ && 
35756                                 (MATCH_w_8_16 >> 3 & 0x7) 
35757                                       /* index at 16 */ < 8)) { 
35758                                 MATCH_w_32_32 = getDword(4 + MATCH_p); 
35759                                 { 
35760                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
35761                                   unsigned i32 = 
35762                                     MATCH_w_32_32 /* i32 at 32 */;
35763                                   nextPC = 8 + MATCH_p; 
35764                                   
35765 #line 387 "frontend/machine/pentium/decoder.m"
35766                                   
35767 
35768                                         stmts = instantiate(pc,  "TEST.Ed.Id", DIS_EADDR32, DIS_I32);
35769 
35770                                   
35771 
35772                                   
35773                                   
35774                                   
35775                                 }
35776                                 
35777                               } /*opt-block*/
35778                               else { 
35779                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
35780                                 goto MATCH_label_c759; 
35781                                 
35782                               } /*opt-block*/
35783                               
35784                               break;
35785                             case 2: 
35786                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35787                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35788                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35789                                       /* index at 16 */ && 
35790                                 (MATCH_w_8_16 >> 3 & 0x7) 
35791                                       /* index at 16 */ < 8)) { 
35792                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
35793                                 goto MATCH_label_c760; 
35794                                 
35795                               } /*opt-block*/
35796                               else { 
35797                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
35798                                 goto MATCH_label_c761; 
35799                                 
35800                               } /*opt-block*/
35801                               
35802                               break;
35803                             case 3: 
35804                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
35805                               goto MATCH_label_c758; 
35806                               
35807                               break;
35808                             default: assert(0);
35809                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
35810                         break;
35811                       case 1: 
35812                         goto MATCH_label_c64; break;
35813                       case 2: 
35814                         
35815                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
35816                             case 0: 
35817                               
35818                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
35819                                   case 0: case 1: case 2: case 3: case 6: 
35820                                   case 7: 
35821                                     goto MATCH_label_c762; break;
35822                                   case 4: 
35823                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
35824                                     if ((MATCH_w_8_16 & 0x7) 
35825                                             /* base at 16 */ == 5 && 
35826                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35827                                             /* index at 16 */ && 
35828                                       (MATCH_w_8_16 >> 3 & 0x7) 
35829                                             /* index at 16 */ < 8)) 
35830                                       goto MATCH_label_c764;  /*opt-block+*/
35831                                     else 
35832                                       goto MATCH_label_c763;  /*opt-block+*/
35833                                     
35834                                     break;
35835                                   case 5: 
35836                                     goto MATCH_label_c765; break;
35837                                   default: assert(0);
35838                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
35839                               break;
35840                             case 1: 
35841                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35842                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35843                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35844                                       /* index at 16 */ && 
35845                                 (MATCH_w_8_16 >> 3 & 0x7) 
35846                                       /* index at 16 */ < 8)) { 
35847                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
35848                                 nextPC = 4 + MATCH_p; 
35849                                 
35850 #line 910 "frontend/machine/pentium/decoder.m"
35851                                 
35852 
35853                                         stmts = instantiate(pc,  "NOTod", DIS_EADDR32);
35854 
35855                                 
35856 
35857                                 
35858                                 
35859                                 
35860                               } /*opt-block*//*opt-block+*/
35861                               else 
35862                                 goto MATCH_label_c763;  /*opt-block+*/
35863                               
35864                               break;
35865                             case 2: 
35866                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35867                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35868                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35869                                       /* index at 16 */ && 
35870                                 (MATCH_w_8_16 >> 3 & 0x7) 
35871                                       /* index at 16 */ < 8)) 
35872                                 goto MATCH_label_c764;  /*opt-block+*/
35873                               else 
35874                                 goto MATCH_label_c765;  /*opt-block+*/
35875                               
35876                               break;
35877                             case 3: 
35878                               goto MATCH_label_c762; break;
35879                             default: assert(0);
35880                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
35881                         break;
35882                       case 3: 
35883                         
35884                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
35885                             case 0: 
35886                               
35887                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
35888                                   case 0: case 1: case 2: case 3: case 6: 
35889                                   case 7: 
35890                                     goto MATCH_label_c766; break;
35891                                   case 4: 
35892                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
35893                                     if ((MATCH_w_8_16 & 0x7) 
35894                                             /* base at 16 */ == 5 && 
35895                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35896                                             /* index at 16 */ && 
35897                                       (MATCH_w_8_16 >> 3 & 0x7) 
35898                                             /* index at 16 */ < 8)) 
35899                                       goto MATCH_label_c768;  /*opt-block+*/
35900                                     else 
35901                                       goto MATCH_label_c767;  /*opt-block+*/
35902                                     
35903                                     break;
35904                                   case 5: 
35905                                     goto MATCH_label_c769; break;
35906                                   default: assert(0);
35907                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
35908                               break;
35909                             case 1: 
35910                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35911                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35912                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35913                                       /* index at 16 */ && 
35914                                 (MATCH_w_8_16 >> 3 & 0x7) 
35915                                       /* index at 16 */ < 8)) { 
35916                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
35917                                 nextPC = 4 + MATCH_p; 
35918                                 
35919 #line 919 "frontend/machine/pentium/decoder.m"
35920                                 
35921 
35922                                         stmts = instantiate(pc,  "NEGod", DIS_EADDR32);
35923 
35924                                 
35925 
35926                                 
35927                                 
35928                                 
35929                               } /*opt-block*//*opt-block+*/
35930                               else 
35931                                 goto MATCH_label_c767;  /*opt-block+*/
35932                               
35933                               break;
35934                             case 2: 
35935                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35936                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35937                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35938                                       /* index at 16 */ && 
35939                                 (MATCH_w_8_16 >> 3 & 0x7) 
35940                                       /* index at 16 */ < 8)) 
35941                                 goto MATCH_label_c768;  /*opt-block+*/
35942                               else 
35943                                 goto MATCH_label_c769;  /*opt-block+*/
35944                               
35945                               break;
35946                             case 3: 
35947                               goto MATCH_label_c766; break;
35948                             default: assert(0);
35949                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
35950                         break;
35951                       case 4: 
35952                         
35953                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
35954                             case 0: 
35955                               
35956                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
35957                                   case 0: case 1: case 2: case 3: case 6: 
35958                                   case 7: 
35959                                     goto MATCH_label_c770; break;
35960                                   case 4: 
35961                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
35962                                     if ((MATCH_w_8_16 & 0x7) 
35963                                             /* base at 16 */ == 5 && 
35964                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35965                                             /* index at 16 */ && 
35966                                       (MATCH_w_8_16 >> 3 & 0x7) 
35967                                             /* index at 16 */ < 8)) 
35968                                       goto MATCH_label_c772;  /*opt-block+*/
35969                                     else 
35970                                       goto MATCH_label_c771;  /*opt-block+*/
35971                                     
35972                                     break;
35973                                   case 5: 
35974                                     goto MATCH_label_c773; break;
35975                                   default: assert(0);
35976                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
35977                               break;
35978                             case 1: 
35979                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
35980                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
35981                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
35982                                       /* index at 16 */ && 
35983                                 (MATCH_w_8_16 >> 3 & 0x7) 
35984                                       /* index at 16 */ < 8)) { 
35985                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
35986                                 nextPC = 4 + MATCH_p; 
35987                                 
35988 #line 928 "frontend/machine/pentium/decoder.m"
35989                                 
35990 
35991                                         stmts = instantiate(pc,  "MUL.AXod", DIS_EADDR32);
35992 
35993                                 
35994 
35995                                 
35996                                 
35997                                 
35998                               } /*opt-block*//*opt-block+*/
35999                               else 
36000                                 goto MATCH_label_c771;  /*opt-block+*/
36001                               
36002                               break;
36003                             case 2: 
36004                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
36005                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
36006                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
36007                                       /* index at 16 */ && 
36008                                 (MATCH_w_8_16 >> 3 & 0x7) 
36009                                       /* index at 16 */ < 8)) 
36010                                 goto MATCH_label_c772;  /*opt-block+*/
36011                               else 
36012                                 goto MATCH_label_c773;  /*opt-block+*/
36013                               
36014                               break;
36015                             case 3: 
36016                               goto MATCH_label_c770; break;
36017                             default: assert(0);
36018                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
36019                         break;
36020                       case 5: 
36021                         
36022                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
36023                             case 0: 
36024                               
36025                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
36026                                   case 0: case 1: case 2: case 3: case 6: 
36027                                   case 7: 
36028                                     goto MATCH_label_c774; break;
36029                                   case 4: 
36030                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
36031                                     if ((MATCH_w_8_16 & 0x7) 
36032                                             /* base at 16 */ == 5 && 
36033                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
36034                                             /* index at 16 */ && 
36035                                       (MATCH_w_8_16 >> 3 & 0x7) 
36036                                             /* index at 16 */ < 8)) 
36037                                       goto MATCH_label_c776;  /*opt-block+*/
36038                                     else 
36039                                       goto MATCH_label_c775;  /*opt-block+*/
36040                                     
36041                                     break;
36042                                   case 5: 
36043                                     goto MATCH_label_c777; break;
36044                                   default: assert(0);
36045                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
36046                               break;
36047                             case 1: 
36048                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
36049                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
36050                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
36051                                       /* index at 16 */ && 
36052                                 (MATCH_w_8_16 >> 3 & 0x7) 
36053                                       /* index at 16 */ < 8)) { 
36054                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
36055                                 nextPC = 4 + MATCH_p; 
36056                                 
36057 #line 1172 "frontend/machine/pentium/decoder.m"
36058                                 
36059 
36060                                         stmts = instantiate(pc,  "IMULod", DIS_EADDR32);
36061 
36062                                 
36063 
36064                                 
36065                                 
36066                                 
36067                               } /*opt-block*//*opt-block+*/
36068                               else 
36069                                 goto MATCH_label_c775;  /*opt-block+*/
36070                               
36071                               break;
36072                             case 2: 
36073                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
36074                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
36075                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
36076                                       /* index at 16 */ && 
36077                                 (MATCH_w_8_16 >> 3 & 0x7) 
36078                                       /* index at 16 */ < 8)) 
36079                                 goto MATCH_label_c776;  /*opt-block+*/
36080                               else 
36081                                 goto MATCH_label_c777;  /*opt-block+*/
36082                               
36083                               break;
36084                             case 3: 
36085                               goto MATCH_label_c774; break;
36086                             default: assert(0);
36087                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
36088                         break;
36089                       case 6: 
36090                         
36091                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
36092                             case 0: 
36093                               
36094                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
36095                                   case 0: case 1: case 2: case 3: case 6: 
36096                                   case 7: 
36097                                     goto MATCH_label_c778; break;
36098                                   case 4: 
36099                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
36100                                     if ((MATCH_w_8_16 & 0x7) 
36101                                             /* base at 16 */ == 5 && 
36102                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
36103                                             /* index at 16 */ && 
36104                                       (MATCH_w_8_16 >> 3 & 0x7) 
36105                                             /* index at 16 */ < 8)) 
36106                                       goto MATCH_label_c780;  /*opt-block+*/
36107                                     else 
36108                                       goto MATCH_label_c779;  /*opt-block+*/
36109                                     
36110                                     break;
36111                                   case 5: 
36112                                     goto MATCH_label_c781; break;
36113                                   default: assert(0);
36114                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
36115                               break;
36116                             case 1: 
36117                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
36118                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
36119                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
36120                                       /* index at 16 */ && 
36121                                 (MATCH_w_8_16 >> 3 & 0x7) 
36122                                       /* index at 16 */ < 8)) { 
36123                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
36124                                 nextPC = 4 + MATCH_p; 
36125                                 
36126 #line 1196 "frontend/machine/pentium/decoder.m"
36127                                 
36128 
36129                                         stmts = instantiate(pc,  "DIVeAX", DIS_EADDR32);
36130 
36131                                 
36132 
36133                                 
36134                                 
36135                                 
36136                               } /*opt-block*//*opt-block+*/
36137                               else 
36138                                 goto MATCH_label_c779;  /*opt-block+*/
36139                               
36140                               break;
36141                             case 2: 
36142                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
36143                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
36144                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
36145                                       /* index at 16 */ && 
36146                                 (MATCH_w_8_16 >> 3 & 0x7) 
36147                                       /* index at 16 */ < 8)) 
36148                                 goto MATCH_label_c780;  /*opt-block+*/
36149                               else 
36150                                 goto MATCH_label_c781;  /*opt-block+*/
36151                               
36152                               break;
36153                             case 3: 
36154                               goto MATCH_label_c778; break;
36155                             default: assert(0);
36156                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
36157                         break;
36158                       case 7: 
36159                         
36160                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
36161                             case 0: 
36162                               
36163                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
36164                                   case 0: case 1: case 2: case 3: case 6: 
36165                                   case 7: 
36166                                     goto MATCH_label_c782; break;
36167                                   case 4: 
36168                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
36169                                     if ((MATCH_w_8_16 & 0x7) 
36170                                             /* base at 16 */ == 5 && 
36171                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
36172                                             /* index at 16 */ && 
36173                                       (MATCH_w_8_16 >> 3 & 0x7) 
36174                                             /* index at 16 */ < 8)) 
36175                                       goto MATCH_label_c784;  /*opt-block+*/
36176                                     else 
36177                                       goto MATCH_label_c783;  /*opt-block+*/
36178                                     
36179                                     break;
36180                                   case 5: 
36181                                     goto MATCH_label_c785; break;
36182                                   default: assert(0);
36183                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
36184                               break;
36185                             case 1: 
36186                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
36187                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
36188                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
36189                                       /* index at 16 */ && 
36190                                 (MATCH_w_8_16 >> 3 & 0x7) 
36191                                       /* index at 16 */ < 8)) { 
36192                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
36193                                 nextPC = 4 + MATCH_p; 
36194                                 
36195 #line 1181 "frontend/machine/pentium/decoder.m"
36196                                 
36197 
36198                                         stmts = instantiate(pc,  "IDIVeAX", DIS_EADDR32);
36199 
36200                                 
36201 
36202                                 
36203                                 
36204                                 
36205                               } /*opt-block*//*opt-block+*/
36206                               else 
36207                                 goto MATCH_label_c783;  /*opt-block+*/
36208                               
36209                               break;
36210                             case 2: 
36211                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
36212                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
36213                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
36214                                       /* index at 16 */ && 
36215                                 (MATCH_w_8_16 >> 3 & 0x7) 
36216                                       /* index at 16 */ < 8)) 
36217                                 goto MATCH_label_c784;  /*opt-block+*/
36218                               else 
36219                                 goto MATCH_label_c785;  /*opt-block+*/
36220                               
36221                               break;
36222                             case 3: 
36223                               goto MATCH_label_c782; break;
36224                             default: assert(0);
36225                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
36226                         break;
36227                       default: assert(0);
36228                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
36229                   
36230                   break;
36231                 default: assert(0);
36232               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
36233             break;
36234           default: assert(0);
36235         } /* (MATCH_w_8_0 >> 4 & 0xf) -- row at 0 --*/  
36236     
36237   }goto MATCH_finished_c; 
36238   
36239   MATCH_label_c0: (void)0; /*placeholder for label*/ 
36240     { 
36241       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36242       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36243       nextPC = 2 + MATCH_p; 
36244       
36245 #line 1546 "frontend/machine/pentium/decoder.m"
36246       
36247 
36248             stmts = instantiate(pc,  "ADDmrb", DIS_EADDR8, DIS_R8);
36249 
36250       
36251 
36252       
36253       
36254       
36255     } 
36256     goto MATCH_finished_c; 
36257     
36258   MATCH_label_c1: (void)0; /*placeholder for label*/ 
36259     { 
36260       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36261       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36262       nextPC = 3 + MATCH_p; 
36263       
36264 #line 1546 "frontend/machine/pentium/decoder.m"
36265       
36266 
36267             stmts = instantiate(pc,  "ADDmrb", DIS_EADDR8, DIS_R8);
36268 
36269       
36270 
36271       
36272       
36273       
36274     } 
36275     goto MATCH_finished_c; 
36276     
36277   MATCH_label_c2: (void)0; /*placeholder for label*/ 
36278     { 
36279       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36280       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36281       nextPC = 7 + MATCH_p; 
36282       
36283 #line 1546 "frontend/machine/pentium/decoder.m"
36284       
36285 
36286             stmts = instantiate(pc,  "ADDmrb", DIS_EADDR8, DIS_R8);
36287 
36288       
36289 
36290       
36291       
36292       
36293     } 
36294     goto MATCH_finished_c; 
36295     
36296   MATCH_label_c3: (void)0; /*placeholder for label*/ 
36297     { 
36298       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36299       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36300       nextPC = 6 + MATCH_p; 
36301       
36302 #line 1546 "frontend/machine/pentium/decoder.m"
36303       
36304 
36305             stmts = instantiate(pc,  "ADDmrb", DIS_EADDR8, DIS_R8);
36306 
36307       
36308 
36309       
36310       
36311       
36312     } 
36313     goto MATCH_finished_c; 
36314     
36315   MATCH_label_c4: (void)0; /*placeholder for label*/ 
36316     { 
36317       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36318       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36319       nextPC = 2 + MATCH_p; 
36320       
36321 #line 1519 "frontend/machine/pentium/decoder.m"
36322       
36323 
36324             stmts = instantiate(pc,  "ADDmrod", DIS_EADDR32, DIS_REG32);
36325 
36326       
36327 
36328       
36329       
36330       
36331     } 
36332     goto MATCH_finished_c; 
36333     
36334   MATCH_label_c5: (void)0; /*placeholder for label*/ 
36335     { 
36336       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36337       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36338       nextPC = 3 + MATCH_p; 
36339       
36340 #line 1519 "frontend/machine/pentium/decoder.m"
36341       
36342 
36343             stmts = instantiate(pc,  "ADDmrod", DIS_EADDR32, DIS_REG32);
36344 
36345       
36346 
36347       
36348       
36349       
36350     } 
36351     goto MATCH_finished_c; 
36352     
36353   MATCH_label_c6: (void)0; /*placeholder for label*/ 
36354     { 
36355       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36356       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36357       nextPC = 7 + MATCH_p; 
36358       
36359 #line 1519 "frontend/machine/pentium/decoder.m"
36360       
36361 
36362             stmts = instantiate(pc,  "ADDmrod", DIS_EADDR32, DIS_REG32);
36363 
36364       
36365 
36366       
36367       
36368       
36369     } 
36370     goto MATCH_finished_c; 
36371     
36372   MATCH_label_c7: (void)0; /*placeholder for label*/ 
36373     { 
36374       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36375       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36376       nextPC = 6 + MATCH_p; 
36377       
36378 #line 1519 "frontend/machine/pentium/decoder.m"
36379       
36380 
36381             stmts = instantiate(pc,  "ADDmrod", DIS_EADDR32, DIS_REG32);
36382 
36383       
36384 
36385       
36386       
36387       
36388     } 
36389     goto MATCH_finished_c; 
36390     
36391   MATCH_label_c8: (void)0; /*placeholder for label*/ 
36392     { 
36393       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36394       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36395       nextPC = 2 + MATCH_p; 
36396       
36397 #line 1474 "frontend/machine/pentium/decoder.m"
36398       
36399 
36400             stmts = instantiate(pc,  "ADDrmb", DIS_R8, DIS_EADDR8);
36401 
36402       
36403 
36404       
36405       
36406       
36407     } 
36408     goto MATCH_finished_c; 
36409     
36410   MATCH_label_c9: (void)0; /*placeholder for label*/ 
36411     { 
36412       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36413       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36414       nextPC = 3 + MATCH_p; 
36415       
36416 #line 1474 "frontend/machine/pentium/decoder.m"
36417       
36418 
36419             stmts = instantiate(pc,  "ADDrmb", DIS_R8, DIS_EADDR8);
36420 
36421       
36422 
36423       
36424       
36425       
36426     } 
36427     goto MATCH_finished_c; 
36428     
36429   MATCH_label_c10: (void)0; /*placeholder for label*/ 
36430     { 
36431       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36432       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36433       nextPC = 7 + MATCH_p; 
36434       
36435 #line 1474 "frontend/machine/pentium/decoder.m"
36436       
36437 
36438             stmts = instantiate(pc,  "ADDrmb", DIS_R8, DIS_EADDR8);
36439 
36440       
36441 
36442       
36443       
36444       
36445     } 
36446     goto MATCH_finished_c; 
36447     
36448   MATCH_label_c11: (void)0; /*placeholder for label*/ 
36449     { 
36450       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36451       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36452       nextPC = 6 + MATCH_p; 
36453       
36454 #line 1474 "frontend/machine/pentium/decoder.m"
36455       
36456 
36457             stmts = instantiate(pc,  "ADDrmb", DIS_R8, DIS_EADDR8);
36458 
36459       
36460 
36461       
36462       
36463       
36464     } 
36465     goto MATCH_finished_c; 
36466     
36467   MATCH_label_c12: (void)0; /*placeholder for label*/ 
36468     { 
36469       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36470       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36471       nextPC = 2 + MATCH_p; 
36472       
36473 #line 1447 "frontend/machine/pentium/decoder.m"
36474       
36475 
36476             stmts = instantiate(pc,  "ADDrmod", DIS_REG32, DIS_EADDR32);
36477 
36478       
36479 
36480       
36481       
36482       
36483     } 
36484     goto MATCH_finished_c; 
36485     
36486   MATCH_label_c13: (void)0; /*placeholder for label*/ 
36487     { 
36488       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36489       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36490       nextPC = 3 + MATCH_p; 
36491       
36492 #line 1447 "frontend/machine/pentium/decoder.m"
36493       
36494 
36495             stmts = instantiate(pc,  "ADDrmod", DIS_REG32, DIS_EADDR32);
36496 
36497       
36498 
36499       
36500       
36501       
36502     } 
36503     goto MATCH_finished_c; 
36504     
36505   MATCH_label_c14: (void)0; /*placeholder for label*/ 
36506     { 
36507       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36508       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36509       nextPC = 7 + MATCH_p; 
36510       
36511 #line 1447 "frontend/machine/pentium/decoder.m"
36512       
36513 
36514             stmts = instantiate(pc,  "ADDrmod", DIS_REG32, DIS_EADDR32);
36515 
36516       
36517 
36518       
36519       
36520       
36521     } 
36522     goto MATCH_finished_c; 
36523     
36524   MATCH_label_c15: (void)0; /*placeholder for label*/ 
36525     { 
36526       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36527       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36528       nextPC = 6 + MATCH_p; 
36529       
36530 #line 1447 "frontend/machine/pentium/decoder.m"
36531       
36532 
36533             stmts = instantiate(pc,  "ADDrmod", DIS_REG32, DIS_EADDR32);
36534 
36535       
36536 
36537       
36538       
36539       
36540     } 
36541     goto MATCH_finished_c; 
36542     
36543   MATCH_label_c16: (void)0; /*placeholder for label*/ 
36544     { 
36545       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36546       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36547       nextPC = 2 + MATCH_p; 
36548       
36549 #line 1540 "frontend/machine/pentium/decoder.m"
36550       
36551 
36552             stmts = instantiate(pc,  "ADCmrb", DIS_EADDR8, DIS_R8);
36553 
36554       
36555 
36556       
36557       
36558       
36559     } 
36560     goto MATCH_finished_c; 
36561     
36562   MATCH_label_c17: (void)0; /*placeholder for label*/ 
36563     { 
36564       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36565       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36566       nextPC = 3 + MATCH_p; 
36567       
36568 #line 1540 "frontend/machine/pentium/decoder.m"
36569       
36570 
36571             stmts = instantiate(pc,  "ADCmrb", DIS_EADDR8, DIS_R8);
36572 
36573       
36574 
36575       
36576       
36577       
36578     } 
36579     goto MATCH_finished_c; 
36580     
36581   MATCH_label_c18: (void)0; /*placeholder for label*/ 
36582     { 
36583       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36584       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36585       nextPC = 7 + MATCH_p; 
36586       
36587 #line 1540 "frontend/machine/pentium/decoder.m"
36588       
36589 
36590             stmts = instantiate(pc,  "ADCmrb", DIS_EADDR8, DIS_R8);
36591 
36592       
36593 
36594       
36595       
36596       
36597     } 
36598     goto MATCH_finished_c; 
36599     
36600   MATCH_label_c19: (void)0; /*placeholder for label*/ 
36601     { 
36602       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36603       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36604       nextPC = 6 + MATCH_p; 
36605       
36606 #line 1540 "frontend/machine/pentium/decoder.m"
36607       
36608 
36609             stmts = instantiate(pc,  "ADCmrb", DIS_EADDR8, DIS_R8);
36610 
36611       
36612 
36613       
36614       
36615       
36616     } 
36617     goto MATCH_finished_c; 
36618     
36619   MATCH_label_c20: (void)0; /*placeholder for label*/ 
36620     { 
36621       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36622       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36623       nextPC = 2 + MATCH_p; 
36624       
36625 #line 1507 "frontend/machine/pentium/decoder.m"
36626       
36627 
36628             stmts = instantiate(pc,  "ADCmrod", DIS_EADDR32, DIS_REG32);
36629 
36630       
36631 
36632       
36633       
36634       
36635     } 
36636     goto MATCH_finished_c; 
36637     
36638   MATCH_label_c21: (void)0; /*placeholder for label*/ 
36639     { 
36640       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36641       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36642       nextPC = 3 + MATCH_p; 
36643       
36644 #line 1507 "frontend/machine/pentium/decoder.m"
36645       
36646 
36647             stmts = instantiate(pc,  "ADCmrod", DIS_EADDR32, DIS_REG32);
36648 
36649       
36650 
36651       
36652       
36653       
36654     } 
36655     goto MATCH_finished_c; 
36656     
36657   MATCH_label_c22: (void)0; /*placeholder for label*/ 
36658     { 
36659       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36660       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36661       nextPC = 7 + MATCH_p; 
36662       
36663 #line 1507 "frontend/machine/pentium/decoder.m"
36664       
36665 
36666             stmts = instantiate(pc,  "ADCmrod", DIS_EADDR32, DIS_REG32);
36667 
36668       
36669 
36670       
36671       
36672       
36673     } 
36674     goto MATCH_finished_c; 
36675     
36676   MATCH_label_c23: (void)0; /*placeholder for label*/ 
36677     { 
36678       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36679       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36680       nextPC = 6 + MATCH_p; 
36681       
36682 #line 1507 "frontend/machine/pentium/decoder.m"
36683       
36684 
36685             stmts = instantiate(pc,  "ADCmrod", DIS_EADDR32, DIS_REG32);
36686 
36687       
36688 
36689       
36690       
36691       
36692     } 
36693     goto MATCH_finished_c; 
36694     
36695   MATCH_label_c24: (void)0; /*placeholder for label*/ 
36696     { 
36697       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36698       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36699       nextPC = 2 + MATCH_p; 
36700       
36701 #line 1468 "frontend/machine/pentium/decoder.m"
36702       
36703 
36704             stmts = instantiate(pc,  "ADCrmb", DIS_R8, DIS_EADDR8);
36705 
36706       
36707 
36708       
36709       
36710       
36711     } 
36712     goto MATCH_finished_c; 
36713     
36714   MATCH_label_c25: (void)0; /*placeholder for label*/ 
36715     { 
36716       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36717       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36718       nextPC = 3 + MATCH_p; 
36719       
36720 #line 1468 "frontend/machine/pentium/decoder.m"
36721       
36722 
36723             stmts = instantiate(pc,  "ADCrmb", DIS_R8, DIS_EADDR8);
36724 
36725       
36726 
36727       
36728       
36729       
36730     } 
36731     goto MATCH_finished_c; 
36732     
36733   MATCH_label_c26: (void)0; /*placeholder for label*/ 
36734     { 
36735       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36736       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36737       nextPC = 7 + MATCH_p; 
36738       
36739 #line 1468 "frontend/machine/pentium/decoder.m"
36740       
36741 
36742             stmts = instantiate(pc,  "ADCrmb", DIS_R8, DIS_EADDR8);
36743 
36744       
36745 
36746       
36747       
36748       
36749     } 
36750     goto MATCH_finished_c; 
36751     
36752   MATCH_label_c27: (void)0; /*placeholder for label*/ 
36753     { 
36754       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36755       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36756       nextPC = 6 + MATCH_p; 
36757       
36758 #line 1468 "frontend/machine/pentium/decoder.m"
36759       
36760 
36761             stmts = instantiate(pc,  "ADCrmb", DIS_R8, DIS_EADDR8);
36762 
36763       
36764 
36765       
36766       
36767       
36768     } 
36769     goto MATCH_finished_c; 
36770     
36771   MATCH_label_c28: (void)0; /*placeholder for label*/ 
36772     { 
36773       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36774       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36775       nextPC = 2 + MATCH_p; 
36776       
36777 #line 1435 "frontend/machine/pentium/decoder.m"
36778       
36779 
36780             stmts = instantiate(pc,  "ADCrmod", DIS_REG32, DIS_EADDR32);
36781 
36782       
36783 
36784       
36785       
36786       
36787     } 
36788     goto MATCH_finished_c; 
36789     
36790   MATCH_label_c29: (void)0; /*placeholder for label*/ 
36791     { 
36792       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36793       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36794       nextPC = 3 + MATCH_p; 
36795       
36796 #line 1435 "frontend/machine/pentium/decoder.m"
36797       
36798 
36799             stmts = instantiate(pc,  "ADCrmod", DIS_REG32, DIS_EADDR32);
36800 
36801       
36802 
36803       
36804       
36805       
36806     } 
36807     goto MATCH_finished_c; 
36808     
36809   MATCH_label_c30: (void)0; /*placeholder for label*/ 
36810     { 
36811       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36812       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36813       nextPC = 7 + MATCH_p; 
36814       
36815 #line 1435 "frontend/machine/pentium/decoder.m"
36816       
36817 
36818             stmts = instantiate(pc,  "ADCrmod", DIS_REG32, DIS_EADDR32);
36819 
36820       
36821 
36822       
36823       
36824       
36825     } 
36826     goto MATCH_finished_c; 
36827     
36828   MATCH_label_c31: (void)0; /*placeholder for label*/ 
36829     { 
36830       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36831       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36832       nextPC = 6 + MATCH_p; 
36833       
36834 #line 1435 "frontend/machine/pentium/decoder.m"
36835       
36836 
36837             stmts = instantiate(pc,  "ADCrmod", DIS_REG32, DIS_EADDR32);
36838 
36839       
36840 
36841       
36842       
36843       
36844     } 
36845     goto MATCH_finished_c; 
36846     
36847   MATCH_label_c32: (void)0; /*placeholder for label*/ 
36848     { 
36849       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36850       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36851       nextPC = 2 + MATCH_p; 
36852       
36853 #line 1534 "frontend/machine/pentium/decoder.m"
36854       
36855 
36856             stmts = instantiate(pc,  "ANDmrb", DIS_EADDR8, DIS_R8);
36857 
36858       
36859 
36860       
36861       
36862       
36863     } 
36864     goto MATCH_finished_c; 
36865     
36866   MATCH_label_c33: (void)0; /*placeholder for label*/ 
36867     { 
36868       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36869       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36870       nextPC = 3 + MATCH_p; 
36871       
36872 #line 1534 "frontend/machine/pentium/decoder.m"
36873       
36874 
36875             stmts = instantiate(pc,  "ANDmrb", DIS_EADDR8, DIS_R8);
36876 
36877       
36878 
36879       
36880       
36881       
36882     } 
36883     goto MATCH_finished_c; 
36884     
36885   MATCH_label_c34: (void)0; /*placeholder for label*/ 
36886     { 
36887       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36888       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36889       nextPC = 7 + MATCH_p; 
36890       
36891 #line 1534 "frontend/machine/pentium/decoder.m"
36892       
36893 
36894             stmts = instantiate(pc,  "ANDmrb", DIS_EADDR8, DIS_R8);
36895 
36896       
36897 
36898       
36899       
36900       
36901     } 
36902     goto MATCH_finished_c; 
36903     
36904   MATCH_label_c35: (void)0; /*placeholder for label*/ 
36905     { 
36906       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36907       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36908       nextPC = 6 + MATCH_p; 
36909       
36910 #line 1534 "frontend/machine/pentium/decoder.m"
36911       
36912 
36913             stmts = instantiate(pc,  "ANDmrb", DIS_EADDR8, DIS_R8);
36914 
36915       
36916 
36917       
36918       
36919       
36920     } 
36921     goto MATCH_finished_c; 
36922     
36923   MATCH_label_c36: (void)0; /*placeholder for label*/ 
36924     { 
36925       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36926       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36927       nextPC = 2 + MATCH_p; 
36928       
36929 #line 1495 "frontend/machine/pentium/decoder.m"
36930       
36931 
36932             stmts = instantiate(pc,  "ANDmrod", DIS_EADDR32, DIS_REG32);
36933 
36934       
36935 
36936       
36937       
36938       
36939     } 
36940     goto MATCH_finished_c; 
36941     
36942   MATCH_label_c37: (void)0; /*placeholder for label*/ 
36943     { 
36944       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36945       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36946       nextPC = 3 + MATCH_p; 
36947       
36948 #line 1495 "frontend/machine/pentium/decoder.m"
36949       
36950 
36951             stmts = instantiate(pc,  "ANDmrod", DIS_EADDR32, DIS_REG32);
36952 
36953       
36954 
36955       
36956       
36957       
36958     } 
36959     goto MATCH_finished_c; 
36960     
36961   MATCH_label_c38: (void)0; /*placeholder for label*/ 
36962     { 
36963       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36964       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36965       nextPC = 7 + MATCH_p; 
36966       
36967 #line 1495 "frontend/machine/pentium/decoder.m"
36968       
36969 
36970             stmts = instantiate(pc,  "ANDmrod", DIS_EADDR32, DIS_REG32);
36971 
36972       
36973 
36974       
36975       
36976       
36977     } 
36978     goto MATCH_finished_c; 
36979     
36980   MATCH_label_c39: (void)0; /*placeholder for label*/ 
36981     { 
36982       unsigned Eaddr = 1 + addressToPC(MATCH_p);
36983       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
36984       nextPC = 6 + MATCH_p; 
36985       
36986 #line 1495 "frontend/machine/pentium/decoder.m"
36987       
36988 
36989             stmts = instantiate(pc,  "ANDmrod", DIS_EADDR32, DIS_REG32);
36990 
36991       
36992 
36993       
36994       
36995       
36996     } 
36997     goto MATCH_finished_c; 
36998     
36999   MATCH_label_c40: (void)0; /*placeholder for label*/ 
37000     { 
37001       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37002       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37003       nextPC = 2 + MATCH_p; 
37004       
37005 #line 1462 "frontend/machine/pentium/decoder.m"
37006       
37007 
37008             stmts = instantiate(pc,  "ANDrmb", DIS_R8, DIS_EADDR8);
37009 
37010       
37011 
37012       
37013       
37014       
37015     } 
37016     goto MATCH_finished_c; 
37017     
37018   MATCH_label_c41: (void)0; /*placeholder for label*/ 
37019     { 
37020       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37021       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37022       nextPC = 3 + MATCH_p; 
37023       
37024 #line 1462 "frontend/machine/pentium/decoder.m"
37025       
37026 
37027             stmts = instantiate(pc,  "ANDrmb", DIS_R8, DIS_EADDR8);
37028 
37029       
37030 
37031       
37032       
37033       
37034     } 
37035     goto MATCH_finished_c; 
37036     
37037   MATCH_label_c42: (void)0; /*placeholder for label*/ 
37038     { 
37039       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37040       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37041       nextPC = 7 + MATCH_p; 
37042       
37043 #line 1462 "frontend/machine/pentium/decoder.m"
37044       
37045 
37046             stmts = instantiate(pc,  "ANDrmb", DIS_R8, DIS_EADDR8);
37047 
37048       
37049 
37050       
37051       
37052       
37053     } 
37054     goto MATCH_finished_c; 
37055     
37056   MATCH_label_c43: (void)0; /*placeholder for label*/ 
37057     { 
37058       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37059       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37060       nextPC = 6 + MATCH_p; 
37061       
37062 #line 1462 "frontend/machine/pentium/decoder.m"
37063       
37064 
37065             stmts = instantiate(pc,  "ANDrmb", DIS_R8, DIS_EADDR8);
37066 
37067       
37068 
37069       
37070       
37071       
37072     } 
37073     goto MATCH_finished_c; 
37074     
37075   MATCH_label_c44: (void)0; /*placeholder for label*/ 
37076     { 
37077       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37078       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37079       nextPC = 2 + MATCH_p; 
37080       
37081 #line 1423 "frontend/machine/pentium/decoder.m"
37082       
37083 
37084             stmts = instantiate(pc,  "ANDrmod", DIS_REG32, DIS_EADDR32);
37085 
37086       
37087 
37088       
37089       
37090       
37091     } 
37092     goto MATCH_finished_c; 
37093     
37094   MATCH_label_c45: (void)0; /*placeholder for label*/ 
37095     { 
37096       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37097       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37098       nextPC = 3 + MATCH_p; 
37099       
37100 #line 1423 "frontend/machine/pentium/decoder.m"
37101       
37102 
37103             stmts = instantiate(pc,  "ANDrmod", DIS_REG32, DIS_EADDR32);
37104 
37105       
37106 
37107       
37108       
37109       
37110     } 
37111     goto MATCH_finished_c; 
37112     
37113   MATCH_label_c46: (void)0; /*placeholder for label*/ 
37114     { 
37115       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37116       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37117       nextPC = 7 + MATCH_p; 
37118       
37119 #line 1423 "frontend/machine/pentium/decoder.m"
37120       
37121 
37122             stmts = instantiate(pc,  "ANDrmod", DIS_REG32, DIS_EADDR32);
37123 
37124       
37125 
37126       
37127       
37128       
37129     } 
37130     goto MATCH_finished_c; 
37131     
37132   MATCH_label_c47: (void)0; /*placeholder for label*/ 
37133     { 
37134       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37135       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37136       nextPC = 6 + MATCH_p; 
37137       
37138 #line 1423 "frontend/machine/pentium/decoder.m"
37139       
37140 
37141             stmts = instantiate(pc,  "ANDrmod", DIS_REG32, DIS_EADDR32);
37142 
37143       
37144 
37145       
37146       
37147       
37148     } 
37149     goto MATCH_finished_c; 
37150     
37151   MATCH_label_c48: (void)0; /*placeholder for label*/ 
37152     { 
37153       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37154       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37155       nextPC = 2 + MATCH_p; 
37156       
37157 #line 1528 "frontend/machine/pentium/decoder.m"
37158       
37159 
37160             stmts = instantiate(pc,  "XORmrb", DIS_EADDR8, DIS_R8);
37161 
37162       
37163 
37164       
37165       
37166       
37167     } 
37168     goto MATCH_finished_c; 
37169     
37170   MATCH_label_c49: (void)0; /*placeholder for label*/ 
37171     { 
37172       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37173       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37174       nextPC = 3 + MATCH_p; 
37175       
37176 #line 1528 "frontend/machine/pentium/decoder.m"
37177       
37178 
37179             stmts = instantiate(pc,  "XORmrb", DIS_EADDR8, DIS_R8);
37180 
37181       
37182 
37183       
37184       
37185       
37186     } 
37187     goto MATCH_finished_c; 
37188     
37189   MATCH_label_c50: (void)0; /*placeholder for label*/ 
37190     { 
37191       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37192       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37193       nextPC = 7 + MATCH_p; 
37194       
37195 #line 1528 "frontend/machine/pentium/decoder.m"
37196       
37197 
37198             stmts = instantiate(pc,  "XORmrb", DIS_EADDR8, DIS_R8);
37199 
37200       
37201 
37202       
37203       
37204       
37205     } 
37206     goto MATCH_finished_c; 
37207     
37208   MATCH_label_c51: (void)0; /*placeholder for label*/ 
37209     { 
37210       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37211       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37212       nextPC = 6 + MATCH_p; 
37213       
37214 #line 1528 "frontend/machine/pentium/decoder.m"
37215       
37216 
37217             stmts = instantiate(pc,  "XORmrb", DIS_EADDR8, DIS_R8);
37218 
37219       
37220 
37221       
37222       
37223       
37224     } 
37225     goto MATCH_finished_c; 
37226     
37227   MATCH_label_c52: (void)0; /*placeholder for label*/ 
37228     { 
37229       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37230       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37231       nextPC = 2 + MATCH_p; 
37232       
37233 #line 1483 "frontend/machine/pentium/decoder.m"
37234       
37235 
37236             stmts = instantiate(pc,  "XORmrod", DIS_EADDR32, DIS_REG32);
37237 
37238       
37239 
37240       
37241       
37242       
37243     } 
37244     goto MATCH_finished_c; 
37245     
37246   MATCH_label_c53: (void)0; /*placeholder for label*/ 
37247     { 
37248       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37249       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37250       nextPC = 3 + MATCH_p; 
37251       
37252 #line 1483 "frontend/machine/pentium/decoder.m"
37253       
37254 
37255             stmts = instantiate(pc,  "XORmrod", DIS_EADDR32, DIS_REG32);
37256 
37257       
37258 
37259       
37260       
37261       
37262     } 
37263     goto MATCH_finished_c; 
37264     
37265   MATCH_label_c54: (void)0; /*placeholder for label*/ 
37266     { 
37267       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37268       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37269       nextPC = 7 + MATCH_p; 
37270       
37271 #line 1483 "frontend/machine/pentium/decoder.m"
37272       
37273 
37274             stmts = instantiate(pc,  "XORmrod", DIS_EADDR32, DIS_REG32);
37275 
37276       
37277 
37278       
37279       
37280       
37281     } 
37282     goto MATCH_finished_c; 
37283     
37284   MATCH_label_c55: (void)0; /*placeholder for label*/ 
37285     { 
37286       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37287       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37288       nextPC = 6 + MATCH_p; 
37289       
37290 #line 1483 "frontend/machine/pentium/decoder.m"
37291       
37292 
37293             stmts = instantiate(pc,  "XORmrod", DIS_EADDR32, DIS_REG32);
37294 
37295       
37296 
37297       
37298       
37299       
37300     } 
37301     goto MATCH_finished_c; 
37302     
37303   MATCH_label_c56: (void)0; /*placeholder for label*/ 
37304     { 
37305       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37306       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37307       nextPC = 2 + MATCH_p; 
37308       
37309 #line 1456 "frontend/machine/pentium/decoder.m"
37310       
37311 
37312             stmts = instantiate(pc,  "XORrmb", DIS_R8, DIS_EADDR8);
37313 
37314       
37315 
37316       
37317       
37318       
37319     } 
37320     goto MATCH_finished_c; 
37321     
37322   MATCH_label_c57: (void)0; /*placeholder for label*/ 
37323     { 
37324       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37325       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37326       nextPC = 3 + MATCH_p; 
37327       
37328 #line 1456 "frontend/machine/pentium/decoder.m"
37329       
37330 
37331             stmts = instantiate(pc,  "XORrmb", DIS_R8, DIS_EADDR8);
37332 
37333       
37334 
37335       
37336       
37337       
37338     } 
37339     goto MATCH_finished_c; 
37340     
37341   MATCH_label_c58: (void)0; /*placeholder for label*/ 
37342     { 
37343       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37344       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37345       nextPC = 7 + MATCH_p; 
37346       
37347 #line 1456 "frontend/machine/pentium/decoder.m"
37348       
37349 
37350             stmts = instantiate(pc,  "XORrmb", DIS_R8, DIS_EADDR8);
37351 
37352       
37353 
37354       
37355       
37356       
37357     } 
37358     goto MATCH_finished_c; 
37359     
37360   MATCH_label_c59: (void)0; /*placeholder for label*/ 
37361     { 
37362       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37363       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37364       nextPC = 6 + MATCH_p; 
37365       
37366 #line 1456 "frontend/machine/pentium/decoder.m"
37367       
37368 
37369             stmts = instantiate(pc,  "XORrmb", DIS_R8, DIS_EADDR8);
37370 
37371       
37372 
37373       
37374       
37375       
37376     } 
37377     goto MATCH_finished_c; 
37378     
37379   MATCH_label_c60: (void)0; /*placeholder for label*/ 
37380     { 
37381       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37382       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37383       nextPC = 2 + MATCH_p; 
37384       
37385 #line 1411 "frontend/machine/pentium/decoder.m"
37386       
37387 
37388             stmts = instantiate(pc,  "XORrmod", DIS_REG32, DIS_EADDR32);
37389 
37390       
37391 
37392       
37393       
37394       
37395     } 
37396     goto MATCH_finished_c; 
37397     
37398   MATCH_label_c61: (void)0; /*placeholder for label*/ 
37399     { 
37400       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37401       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37402       nextPC = 3 + MATCH_p; 
37403       
37404 #line 1411 "frontend/machine/pentium/decoder.m"
37405       
37406 
37407             stmts = instantiate(pc,  "XORrmod", DIS_REG32, DIS_EADDR32);
37408 
37409       
37410 
37411       
37412       
37413       
37414     } 
37415     goto MATCH_finished_c; 
37416     
37417   MATCH_label_c62: (void)0; /*placeholder for label*/ 
37418     { 
37419       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37420       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37421       nextPC = 7 + MATCH_p; 
37422       
37423 #line 1411 "frontend/machine/pentium/decoder.m"
37424       
37425 
37426             stmts = instantiate(pc,  "XORrmod", DIS_REG32, DIS_EADDR32);
37427 
37428       
37429 
37430       
37431       
37432       
37433     } 
37434     goto MATCH_finished_c; 
37435     
37436   MATCH_label_c63: (void)0; /*placeholder for label*/ 
37437     { 
37438       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37439       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37440       nextPC = 6 + MATCH_p; 
37441       
37442 #line 1411 "frontend/machine/pentium/decoder.m"
37443       
37444 
37445             stmts = instantiate(pc,  "XORrmod", DIS_REG32, DIS_EADDR32);
37446 
37447       
37448 
37449       
37450       
37451       
37452     } 
37453     goto MATCH_finished_c; 
37454     
37455   MATCH_label_c64: (void)0; /*placeholder for label*/ 
37456     { 
37457       nextPC = MATCH_p; 
37458       
37459 #line 2119 "frontend/machine/pentium/decoder.m"
37460       
37461             result.valid = false;       // Invalid instruction
37462 
37463             result.rtl = NULL;
37464 
37465             result.numBytes = 0;
37466 
37467             return result;
37468 
37469       
37470       
37471       
37472     } 
37473     goto MATCH_finished_c; 
37474     
37475   MATCH_label_c65: (void)0; /*placeholder for label*/ 
37476     { 
37477       unsigned Eaddr = 2 + addressToPC(MATCH_p);
37478       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
37479       nextPC = 3 + MATCH_p; 
37480       
37481 #line 1522 "frontend/machine/pentium/decoder.m"
37482       
37483 
37484             stmts = instantiate(pc,  "ADDmrow", DIS_EADDR16, DIS_REG16);
37485 
37486       
37487 
37488       
37489       
37490       
37491     } 
37492     goto MATCH_finished_c; 
37493     
37494   MATCH_label_c66: (void)0; /*placeholder for label*/ 
37495     { 
37496       unsigned Eaddr = 2 + addressToPC(MATCH_p);
37497       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
37498       nextPC = 4 + MATCH_p; 
37499       
37500 #line 1522 "frontend/machine/pentium/decoder.m"
37501       
37502 
37503             stmts = instantiate(pc,  "ADDmrow", DIS_EADDR16, DIS_REG16);
37504 
37505       
37506 
37507       
37508       
37509       
37510     } 
37511     goto MATCH_finished_c; 
37512     
37513   MATCH_label_c67: (void)0; /*placeholder for label*/ 
37514     { 
37515       unsigned Eaddr = 2 + addressToPC(MATCH_p);
37516       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
37517       nextPC = 8 + MATCH_p; 
37518       
37519 #line 1522 "frontend/machine/pentium/decoder.m"
37520       
37521 
37522             stmts = instantiate(pc,  "ADDmrow", DIS_EADDR16, DIS_REG16);
37523 
37524       
37525 
37526       
37527       
37528       
37529     } 
37530     goto MATCH_finished_c; 
37531     
37532   MATCH_label_c68: (void)0; /*placeholder for label*/ 
37533     { 
37534       unsigned Eaddr = 2 + addressToPC(MATCH_p);
37535       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
37536       nextPC = 7 + MATCH_p; 
37537       
37538 #line 1522 "frontend/machine/pentium/decoder.m"
37539       
37540 
37541             stmts = instantiate(pc,  "ADDmrow", DIS_EADDR16, DIS_REG16);
37542 
37543       
37544 
37545       
37546       
37547       
37548     } 
37549     goto MATCH_finished_c; 
37550     
37551   MATCH_label_c69: (void)0; /*placeholder for label*/ 
37552     { 
37553       unsigned Eaddr = 2 + addressToPC(MATCH_p);
37554       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
37555       nextPC = 3 + MATCH_p; 
37556       
37557 #line 1516 "frontend/machine/pentium/decoder.m"
37558       
37559 
37560             stmts = instantiate(pc,  "ORmrow", DIS_EADDR16, DIS_REG16);
37561 
37562       
37563 
37564       
37565       
37566       
37567     } 
37568     goto MATCH_finished_c; 
37569     
37570   MATCH_label_c70: (void)0; /*placeholder for label*/ 
37571     { 
37572       unsigned Eaddr = 2 + addressToPC(MATCH_p);
37573       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
37574       nextPC = 4 + MATCH_p; 
37575       
37576 #line 1516 "frontend/machine/pentium/decoder.m"
37577       
37578 
37579             stmts = instantiate(pc,  "ORmrow", DIS_EADDR16, DIS_REG16);
37580 
37581       
37582 
37583       
37584       
37585       
37586     } 
37587     goto MATCH_finished_c; 
37588     
37589   MATCH_label_c71: (void)0; /*placeholder for label*/ 
37590     { 
37591       unsigned Eaddr = 2 + addressToPC(MATCH_p);
37592       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
37593       nextPC = 8 + MATCH_p; 
37594       
37595 #line 1516 "frontend/machine/pentium/decoder.m"
37596       
37597 
37598             stmts = instantiate(pc,  "ORmrow", DIS_EADDR16, DIS_REG16);
37599 
37600       
37601 
37602       
37603       
37604       
37605     } 
37606     goto MATCH_finished_c; 
37607     
37608   MATCH_label_c72: (void)0; /*placeholder for label*/ 
37609     { 
37610       unsigned Eaddr = 2 + addressToPC(MATCH_p);
37611       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
37612       nextPC = 7 + MATCH_p; 
37613       
37614 #line 1516 "frontend/machine/pentium/decoder.m"
37615       
37616 
37617             stmts = instantiate(pc,  "ORmrow", DIS_EADDR16, DIS_REG16);
37618 
37619       
37620 
37621       
37622       
37623       
37624     } 
37625     goto MATCH_finished_c; 
37626     
37627   MATCH_label_c73: (void)0; /*placeholder for label*/ 
37628     { 
37629       unsigned Eaddr = 2 + addressToPC(MATCH_p);
37630       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
37631       nextPC = 3 + MATCH_p; 
37632       
37633 #line 1450 "frontend/machine/pentium/decoder.m"
37634       
37635 
37636             stmts = instantiate(pc,  "ADDrmow", DIS_REG16, DIS_EADDR16);
37637 
37638       
37639 
37640       
37641       
37642       
37643     } 
37644     goto MATCH_finished_c; 
37645     
37646   MATCH_label_c74: (void)0; /*placeholder for label*/ 
37647     { 
37648       unsigned Eaddr = 2 + addressToPC(MATCH_p);
37649       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
37650       nextPC = 4 + MATCH_p; 
37651       
37652 #line 1450 "frontend/machine/pentium/decoder.m"
37653       
37654 
37655             stmts = instantiate(pc,  "ADDrmow", DIS_REG16, DIS_EADDR16);
37656 
37657       
37658 
37659       
37660       
37661       
37662     } 
37663     goto MATCH_finished_c; 
37664     
37665   MATCH_label_c75: (void)0; /*placeholder for label*/ 
37666     { 
37667       unsigned Eaddr = 2 + addressToPC(MATCH_p);
37668       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
37669       nextPC = 8 + MATCH_p; 
37670       
37671 #line 1450 "frontend/machine/pentium/decoder.m"
37672       
37673 
37674             stmts = instantiate(pc,  "ADDrmow", DIS_REG16, DIS_EADDR16);
37675 
37676       
37677 
37678       
37679       
37680       
37681     } 
37682     goto MATCH_finished_c; 
37683     
37684   MATCH_label_c76: (void)0; /*placeholder for label*/ 
37685     { 
37686       unsigned Eaddr = 2 + addressToPC(MATCH_p);
37687       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
37688       nextPC = 7 + MATCH_p; 
37689       
37690 #line 1450 "frontend/machine/pentium/decoder.m"
37691       
37692 
37693             stmts = instantiate(pc,  "ADDrmow", DIS_REG16, DIS_EADDR16);
37694 
37695       
37696 
37697       
37698       
37699       
37700     } 
37701     goto MATCH_finished_c; 
37702     
37703   MATCH_label_c77: (void)0; /*placeholder for label*/ 
37704     { 
37705       unsigned Eaddr = 2 + addressToPC(MATCH_p);
37706       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
37707       nextPC = 3 + MATCH_p; 
37708       
37709 #line 1444 "frontend/machine/pentium/decoder.m"
37710       
37711 
37712             stmts = instantiate(pc,  "ORrmow", DIS_REG16, DIS_EADDR16);
37713 
37714       
37715 
37716       
37717       
37718       
37719     } 
37720     goto MATCH_finished_c; 
37721     
37722   MATCH_label_c78: (void)0; /*placeholder for label*/ 
37723     { 
37724       unsigned Eaddr = 2 + addressToPC(MATCH_p);
37725       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
37726       nextPC = 4 + MATCH_p; 
37727       
37728 #line 1444 "frontend/machine/pentium/decoder.m"
37729       
37730 
37731             stmts = instantiate(pc,  "ORrmow", DIS_REG16, DIS_EADDR16);
37732 
37733       
37734 
37735       
37736       
37737       
37738     } 
37739     goto MATCH_finished_c; 
37740     
37741   MATCH_label_c79: (void)0; /*placeholder for label*/ 
37742     { 
37743       unsigned Eaddr = 2 + addressToPC(MATCH_p);
37744       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
37745       nextPC = 8 + MATCH_p; 
37746       
37747 #line 1444 "frontend/machine/pentium/decoder.m"
37748       
37749 
37750             stmts = instantiate(pc,  "ORrmow", DIS_REG16, DIS_EADDR16);
37751 
37752       
37753 
37754       
37755       
37756       
37757     } 
37758     goto MATCH_finished_c; 
37759     
37760   MATCH_label_c80: (void)0; /*placeholder for label*/ 
37761     { 
37762       unsigned Eaddr = 2 + addressToPC(MATCH_p);
37763       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
37764       nextPC = 7 + MATCH_p; 
37765       
37766 #line 1444 "frontend/machine/pentium/decoder.m"
37767       
37768 
37769             stmts = instantiate(pc,  "ORrmow", DIS_REG16, DIS_EADDR16);
37770 
37771       
37772 
37773       
37774       
37775       
37776     } 
37777     goto MATCH_finished_c; 
37778     
37779   MATCH_label_c81: (void)0; /*placeholder for label*/ 
37780     { 
37781       unsigned Eaddr = 3 + addressToPC(MATCH_p);
37782       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
37783       nextPC = 4 + MATCH_p; 
37784       
37785 #line 1085 "frontend/machine/pentium/decoder.m"
37786       
37787 
37788             stmts = instantiate(pc,  "LAR.ow", DIS_REG16, DIS_EADDR16);
37789 
37790       
37791 
37792       
37793       
37794       
37795     } 
37796     goto MATCH_finished_c; 
37797     
37798   MATCH_label_c82: (void)0; /*placeholder for label*/ 
37799     { 
37800       unsigned Eaddr = 3 + addressToPC(MATCH_p);
37801       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
37802       nextPC = 5 + MATCH_p; 
37803       
37804 #line 1085 "frontend/machine/pentium/decoder.m"
37805       
37806 
37807             stmts = instantiate(pc,  "LAR.ow", DIS_REG16, DIS_EADDR16);
37808 
37809       
37810 
37811       
37812       
37813       
37814     } 
37815     goto MATCH_finished_c; 
37816     
37817   MATCH_label_c83: (void)0; /*placeholder for label*/ 
37818     { 
37819       unsigned Eaddr = 3 + addressToPC(MATCH_p);
37820       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
37821       nextPC = 9 + MATCH_p; 
37822       
37823 #line 1085 "frontend/machine/pentium/decoder.m"
37824       
37825 
37826             stmts = instantiate(pc,  "LAR.ow", DIS_REG16, DIS_EADDR16);
37827 
37828       
37829 
37830       
37831       
37832       
37833     } 
37834     goto MATCH_finished_c; 
37835     
37836   MATCH_label_c84: (void)0; /*placeholder for label*/ 
37837     { 
37838       unsigned Eaddr = 3 + addressToPC(MATCH_p);
37839       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
37840       nextPC = 8 + MATCH_p; 
37841       
37842 #line 1085 "frontend/machine/pentium/decoder.m"
37843       
37844 
37845             stmts = instantiate(pc,  "LAR.ow", DIS_REG16, DIS_EADDR16);
37846 
37847       
37848 
37849       
37850       
37851       
37852     } 
37853     goto MATCH_finished_c; 
37854     
37855   MATCH_label_c85: (void)0; /*placeholder for label*/ 
37856     { 
37857       unsigned Eaddr = 3 + addressToPC(MATCH_p);
37858       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
37859       nextPC = 4 + MATCH_p; 
37860       
37861 #line 1049 "frontend/machine/pentium/decoder.m"
37862       
37863 
37864             stmts = instantiate(pc,  "LSLow", DIS_REG16, DIS_EADDR16);
37865 
37866       
37867 
37868       
37869       
37870       
37871     } 
37872     goto MATCH_finished_c; 
37873     
37874   MATCH_label_c86: (void)0; /*placeholder for label*/ 
37875     { 
37876       unsigned Eaddr = 3 + addressToPC(MATCH_p);
37877       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
37878       nextPC = 5 + MATCH_p; 
37879       
37880 #line 1049 "frontend/machine/pentium/decoder.m"
37881       
37882 
37883             stmts = instantiate(pc,  "LSLow", DIS_REG16, DIS_EADDR16);
37884 
37885       
37886 
37887       
37888       
37889       
37890     } 
37891     goto MATCH_finished_c; 
37892     
37893   MATCH_label_c87: (void)0; /*placeholder for label*/ 
37894     { 
37895       unsigned Eaddr = 3 + addressToPC(MATCH_p);
37896       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
37897       nextPC = 9 + MATCH_p; 
37898       
37899 #line 1049 "frontend/machine/pentium/decoder.m"
37900       
37901 
37902             stmts = instantiate(pc,  "LSLow", DIS_REG16, DIS_EADDR16);
37903 
37904       
37905 
37906       
37907       
37908       
37909     } 
37910     goto MATCH_finished_c; 
37911     
37912   MATCH_label_c88: (void)0; /*placeholder for label*/ 
37913     { 
37914       unsigned Eaddr = 3 + addressToPC(MATCH_p);
37915       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
37916       nextPC = 8 + MATCH_p; 
37917       
37918 #line 1049 "frontend/machine/pentium/decoder.m"
37919       
37920 
37921             stmts = instantiate(pc,  "LSLow", DIS_REG16, DIS_EADDR16);
37922 
37923       
37924 
37925       
37926       
37927       
37928     } 
37929     goto MATCH_finished_c; 
37930     
37931   MATCH_label_c89: (void)0; /*placeholder for label*/ 
37932     { 
37933       unsigned Eaddr = 3 + addressToPC(MATCH_p);
37934       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
37935       nextPC = 4 + MATCH_p; 
37936       
37937 #line 1355 "frontend/machine/pentium/decoder.m"
37938       
37939 
37940             stmts = instantiate(pc,  "BTow", DIS_EADDR16, DIS_REG16);
37941 
37942       
37943 
37944       
37945       
37946       
37947     } 
37948     goto MATCH_finished_c; 
37949     
37950   MATCH_label_c90: (void)0; /*placeholder for label*/ 
37951     { 
37952       unsigned Eaddr = 3 + addressToPC(MATCH_p);
37953       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
37954       nextPC = 5 + MATCH_p; 
37955       
37956 #line 1355 "frontend/machine/pentium/decoder.m"
37957       
37958 
37959             stmts = instantiate(pc,  "BTow", DIS_EADDR16, DIS_REG16);
37960 
37961       
37962 
37963       
37964       
37965       
37966     } 
37967     goto MATCH_finished_c; 
37968     
37969   MATCH_label_c91: (void)0; /*placeholder for label*/ 
37970     { 
37971       unsigned Eaddr = 3 + addressToPC(MATCH_p);
37972       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
37973       nextPC = 9 + MATCH_p; 
37974       
37975 #line 1355 "frontend/machine/pentium/decoder.m"
37976       
37977 
37978             stmts = instantiate(pc,  "BTow", DIS_EADDR16, DIS_REG16);
37979 
37980       
37981 
37982       
37983       
37984       
37985     } 
37986     goto MATCH_finished_c; 
37987     
37988   MATCH_label_c92: (void)0; /*placeholder for label*/ 
37989     { 
37990       unsigned Eaddr = 3 + addressToPC(MATCH_p);
37991       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
37992       nextPC = 8 + MATCH_p; 
37993       
37994 #line 1355 "frontend/machine/pentium/decoder.m"
37995       
37996 
37997             stmts = instantiate(pc,  "BTow", DIS_EADDR16, DIS_REG16);
37998 
37999       
38000 
38001       
38002       
38003       
38004     } 
38005     goto MATCH_finished_c; 
38006     
38007   MATCH_label_c93: (void)0; /*placeholder for label*/ 
38008     { 
38009       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38010       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38011       nextPC = 4 + MATCH_p; 
38012       
38013 #line 1319 "frontend/machine/pentium/decoder.m"
38014       
38015 
38016             stmts = instantiate(pc,  "BTSow", DIS_EADDR16, DIS_REG16);
38017 
38018       
38019 
38020       
38021       
38022       
38023     } 
38024     goto MATCH_finished_c; 
38025     
38026   MATCH_label_c94: (void)0; /*placeholder for label*/ 
38027     { 
38028       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38029       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38030       nextPC = 5 + MATCH_p; 
38031       
38032 #line 1319 "frontend/machine/pentium/decoder.m"
38033       
38034 
38035             stmts = instantiate(pc,  "BTSow", DIS_EADDR16, DIS_REG16);
38036 
38037       
38038 
38039       
38040       
38041       
38042     } 
38043     goto MATCH_finished_c; 
38044     
38045   MATCH_label_c95: (void)0; /*placeholder for label*/ 
38046     { 
38047       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38048       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38049       nextPC = 9 + MATCH_p; 
38050       
38051 #line 1319 "frontend/machine/pentium/decoder.m"
38052       
38053 
38054             stmts = instantiate(pc,  "BTSow", DIS_EADDR16, DIS_REG16);
38055 
38056       
38057 
38058       
38059       
38060       
38061     } 
38062     goto MATCH_finished_c; 
38063     
38064   MATCH_label_c96: (void)0; /*placeholder for label*/ 
38065     { 
38066       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38067       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38068       nextPC = 8 + MATCH_p; 
38069       
38070 #line 1319 "frontend/machine/pentium/decoder.m"
38071       
38072 
38073             stmts = instantiate(pc,  "BTSow", DIS_EADDR16, DIS_REG16);
38074 
38075       
38076 
38077       
38078       
38079       
38080     } 
38081     goto MATCH_finished_c; 
38082     
38083   MATCH_label_c97: (void)0; /*placeholder for label*/ 
38084     { 
38085       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38086       unsigned count = (MATCH_w_8_32 & 0xff) /* i8 at 32 */;
38087       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38088       nextPC = 5 + MATCH_p; 
38089       
38090 #line 447 "frontend/machine/pentium/decoder.m"
38091       
38092 
38093             stmts = instantiate(pc,  "SHLD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
38094 
38095       
38096 
38097       
38098       
38099       
38100     } 
38101     goto MATCH_finished_c; 
38102     
38103   MATCH_label_c98: (void)0; /*placeholder for label*/ 
38104     { 
38105       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38106       unsigned count = (MATCH_w_8_40 & 0xff) /* i8 at 40 */;
38107       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38108       nextPC = 6 + MATCH_p; 
38109       
38110 #line 447 "frontend/machine/pentium/decoder.m"
38111       
38112 
38113             stmts = instantiate(pc,  "SHLD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
38114 
38115       
38116 
38117       
38118       
38119       
38120     } 
38121     goto MATCH_finished_c; 
38122     
38123   MATCH_label_c99: (void)0; /*placeholder for label*/ 
38124     { 
38125       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38126       unsigned count = (MATCH_w_8_72 & 0xff) /* i8 at 72 */;
38127       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38128       nextPC = 10 + MATCH_p; 
38129       
38130 #line 447 "frontend/machine/pentium/decoder.m"
38131       
38132 
38133             stmts = instantiate(pc,  "SHLD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
38134 
38135       
38136 
38137       
38138       
38139       
38140     } 
38141     goto MATCH_finished_c; 
38142     
38143   MATCH_label_c100: (void)0; /*placeholder for label*/ 
38144     { 
38145       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38146       unsigned count = (MATCH_w_8_64 & 0xff) /* i8 at 64 */;
38147       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38148       nextPC = 9 + MATCH_p; 
38149       
38150 #line 447 "frontend/machine/pentium/decoder.m"
38151       
38152 
38153             stmts = instantiate(pc,  "SHLD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
38154 
38155       
38156 
38157       
38158       
38159       
38160     } 
38161     goto MATCH_finished_c; 
38162     
38163   MATCH_label_c101: (void)0; /*placeholder for label*/ 
38164     { 
38165       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38166       unsigned count = (MATCH_w_8_32 & 0xff) /* i8 at 32 */;
38167       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38168       nextPC = 5 + MATCH_p; 
38169       
38170 #line 453 "frontend/machine/pentium/decoder.m"
38171       
38172 
38173             stmts = instantiate(pc,  "SHRD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
38174 
38175       
38176 
38177       
38178       
38179       
38180     } 
38181     goto MATCH_finished_c; 
38182     
38183   MATCH_label_c102: (void)0; /*placeholder for label*/ 
38184     { 
38185       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38186       unsigned count = (MATCH_w_8_40 & 0xff) /* i8 at 40 */;
38187       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38188       nextPC = 6 + MATCH_p; 
38189       
38190 #line 453 "frontend/machine/pentium/decoder.m"
38191       
38192 
38193             stmts = instantiate(pc,  "SHRD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
38194 
38195       
38196 
38197       
38198       
38199       
38200     } 
38201     goto MATCH_finished_c; 
38202     
38203   MATCH_label_c103: (void)0; /*placeholder for label*/ 
38204     { 
38205       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38206       unsigned count = (MATCH_w_8_72 & 0xff) /* i8 at 72 */;
38207       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38208       nextPC = 10 + MATCH_p; 
38209       
38210 #line 453 "frontend/machine/pentium/decoder.m"
38211       
38212 
38213             stmts = instantiate(pc,  "SHRD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
38214 
38215       
38216 
38217       
38218       
38219       
38220     } 
38221     goto MATCH_finished_c; 
38222     
38223   MATCH_label_c104: (void)0; /*placeholder for label*/ 
38224     { 
38225       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38226       unsigned count = (MATCH_w_8_64 & 0xff) /* i8 at 64 */;
38227       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38228       nextPC = 9 + MATCH_p; 
38229       
38230 #line 453 "frontend/machine/pentium/decoder.m"
38231       
38232 
38233             stmts = instantiate(pc,  "SHRD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
38234 
38235       
38236 
38237       
38238       
38239       
38240     } 
38241     goto MATCH_finished_c; 
38242     
38243   MATCH_label_c105: (void)0; /*placeholder for label*/ 
38244     { 
38245       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38246       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38247       nextPC = 4 + MATCH_p; 
38248       
38249 #line 435 "frontend/machine/pentium/decoder.m"
38250       
38251 
38252             stmts = instantiate(pc,  "SHLD.CLow", DIS_EADDR16, DIS_REG16);
38253 
38254       
38255 
38256       
38257       
38258       
38259     } 
38260     goto MATCH_finished_c; 
38261     
38262   MATCH_label_c106: (void)0; /*placeholder for label*/ 
38263     { 
38264       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38265       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38266       nextPC = 5 + MATCH_p; 
38267       
38268 #line 435 "frontend/machine/pentium/decoder.m"
38269       
38270 
38271             stmts = instantiate(pc,  "SHLD.CLow", DIS_EADDR16, DIS_REG16);
38272 
38273       
38274 
38275       
38276       
38277       
38278     } 
38279     goto MATCH_finished_c; 
38280     
38281   MATCH_label_c107: (void)0; /*placeholder for label*/ 
38282     { 
38283       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38284       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38285       nextPC = 9 + MATCH_p; 
38286       
38287 #line 435 "frontend/machine/pentium/decoder.m"
38288       
38289 
38290             stmts = instantiate(pc,  "SHLD.CLow", DIS_EADDR16, DIS_REG16);
38291 
38292       
38293 
38294       
38295       
38296       
38297     } 
38298     goto MATCH_finished_c; 
38299     
38300   MATCH_label_c108: (void)0; /*placeholder for label*/ 
38301     { 
38302       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38303       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38304       nextPC = 8 + MATCH_p; 
38305       
38306 #line 435 "frontend/machine/pentium/decoder.m"
38307       
38308 
38309             stmts = instantiate(pc,  "SHLD.CLow", DIS_EADDR16, DIS_REG16);
38310 
38311       
38312 
38313       
38314       
38315       
38316     } 
38317     goto MATCH_finished_c; 
38318     
38319   MATCH_label_c109: (void)0; /*placeholder for label*/ 
38320     { 
38321       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38322       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38323       nextPC = 4 + MATCH_p; 
38324       
38325 #line 441 "frontend/machine/pentium/decoder.m"
38326       
38327 
38328             stmts = instantiate(pc,  "SHRD.CLow", DIS_EADDR16, DIS_REG16);
38329 
38330       
38331 
38332       
38333       
38334       
38335     } 
38336     goto MATCH_finished_c; 
38337     
38338   MATCH_label_c110: (void)0; /*placeholder for label*/ 
38339     { 
38340       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38341       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38342       nextPC = 5 + MATCH_p; 
38343       
38344 #line 441 "frontend/machine/pentium/decoder.m"
38345       
38346 
38347             stmts = instantiate(pc,  "SHRD.CLow", DIS_EADDR16, DIS_REG16);
38348 
38349       
38350 
38351       
38352       
38353       
38354     } 
38355     goto MATCH_finished_c; 
38356     
38357   MATCH_label_c111: (void)0; /*placeholder for label*/ 
38358     { 
38359       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38360       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38361       nextPC = 9 + MATCH_p; 
38362       
38363 #line 441 "frontend/machine/pentium/decoder.m"
38364       
38365 
38366             stmts = instantiate(pc,  "SHRD.CLow", DIS_EADDR16, DIS_REG16);
38367 
38368       
38369 
38370       
38371       
38372       
38373     } 
38374     goto MATCH_finished_c; 
38375     
38376   MATCH_label_c112: (void)0; /*placeholder for label*/ 
38377     { 
38378       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38379       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38380       nextPC = 8 + MATCH_p; 
38381       
38382 #line 441 "frontend/machine/pentium/decoder.m"
38383       
38384 
38385             stmts = instantiate(pc,  "SHRD.CLow", DIS_EADDR16, DIS_REG16);
38386 
38387       
38388 
38389       
38390       
38391       
38392     } 
38393     goto MATCH_finished_c; 
38394     
38395   MATCH_label_c113: (void)0; /*placeholder for label*/ 
38396     { 
38397       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38398       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38399       nextPC = 4 + MATCH_p; 
38400       
38401 #line 1169 "frontend/machine/pentium/decoder.m"
38402       
38403 
38404             stmts = instantiate(pc,  "IMULrmow", DIS_REG16, DIS_EADDR16);
38405 
38406       
38407 
38408       
38409       
38410       
38411     } 
38412     goto MATCH_finished_c; 
38413     
38414   MATCH_label_c114: (void)0; /*placeholder for label*/ 
38415     { 
38416       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38417       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38418       nextPC = 5 + MATCH_p; 
38419       
38420 #line 1169 "frontend/machine/pentium/decoder.m"
38421       
38422 
38423             stmts = instantiate(pc,  "IMULrmow", DIS_REG16, DIS_EADDR16);
38424 
38425       
38426 
38427       
38428       
38429       
38430     } 
38431     goto MATCH_finished_c; 
38432     
38433   MATCH_label_c115: (void)0; /*placeholder for label*/ 
38434     { 
38435       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38436       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38437       nextPC = 9 + MATCH_p; 
38438       
38439 #line 1169 "frontend/machine/pentium/decoder.m"
38440       
38441 
38442             stmts = instantiate(pc,  "IMULrmow", DIS_REG16, DIS_EADDR16);
38443 
38444       
38445 
38446       
38447       
38448       
38449     } 
38450     goto MATCH_finished_c; 
38451     
38452   MATCH_label_c116: (void)0; /*placeholder for label*/ 
38453     { 
38454       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38455       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38456       nextPC = 8 + MATCH_p; 
38457       
38458 #line 1169 "frontend/machine/pentium/decoder.m"
38459       
38460 
38461             stmts = instantiate(pc,  "IMULrmow", DIS_REG16, DIS_EADDR16);
38462 
38463       
38464 
38465       
38466       
38467       
38468     } 
38469     goto MATCH_finished_c; 
38470     
38471   MATCH_label_c117: (void)0; /*placeholder for label*/ 
38472     { 
38473       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38474       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38475       nextPC = 4 + MATCH_p; 
38476       
38477 #line 1241 "frontend/machine/pentium/decoder.m"
38478       
38479 
38480             stmts = instantiate(pc,  "CMPXCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
38481 
38482       
38483 
38484       
38485       
38486       
38487     } 
38488     goto MATCH_finished_c; 
38489     
38490   MATCH_label_c118: (void)0; /*placeholder for label*/ 
38491     { 
38492       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38493       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38494       nextPC = 5 + MATCH_p; 
38495       
38496 #line 1241 "frontend/machine/pentium/decoder.m"
38497       
38498 
38499             stmts = instantiate(pc,  "CMPXCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
38500 
38501       
38502 
38503       
38504       
38505       
38506     } 
38507     goto MATCH_finished_c; 
38508     
38509   MATCH_label_c119: (void)0; /*placeholder for label*/ 
38510     { 
38511       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38512       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38513       nextPC = 9 + MATCH_p; 
38514       
38515 #line 1241 "frontend/machine/pentium/decoder.m"
38516       
38517 
38518             stmts = instantiate(pc,  "CMPXCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
38519 
38520       
38521 
38522       
38523       
38524       
38525     } 
38526     goto MATCH_finished_c; 
38527     
38528   MATCH_label_c120: (void)0; /*placeholder for label*/ 
38529     { 
38530       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38531       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38532       nextPC = 8 + MATCH_p; 
38533       
38534 #line 1241 "frontend/machine/pentium/decoder.m"
38535       
38536 
38537             stmts = instantiate(pc,  "CMPXCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
38538 
38539       
38540 
38541       
38542       
38543       
38544     } 
38545     goto MATCH_finished_c; 
38546     
38547   MATCH_label_c121: (void)0; /*placeholder for label*/ 
38548     { 
38549       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38550       int /* [~128..127] */ i8 = 
38551         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
38552       nextPC = 5 + MATCH_p; 
38553       
38554 #line 1349 "frontend/machine/pentium/decoder.m"
38555       
38556 
38557             stmts = instantiate(pc,  "BTiow", DIS_EADDR16, DIS_I8);
38558 
38559       
38560 
38561       
38562       
38563       
38564     } 
38565     goto MATCH_finished_c; 
38566     
38567   MATCH_label_c122: (void)0; /*placeholder for label*/ 
38568     { 
38569       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38570       int /* [~128..127] */ i8 = 
38571         sign_extend((MATCH_w_8_40 & 0xff) /* i8 at 40 */, 8);
38572       nextPC = 6 + MATCH_p; 
38573       
38574 #line 1349 "frontend/machine/pentium/decoder.m"
38575       
38576 
38577             stmts = instantiate(pc,  "BTiow", DIS_EADDR16, DIS_I8);
38578 
38579       
38580 
38581       
38582       
38583       
38584     } 
38585     goto MATCH_finished_c; 
38586     
38587   MATCH_label_c123: (void)0; /*placeholder for label*/ 
38588     { 
38589       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38590       int /* [~128..127] */ i8 = 
38591         sign_extend((MATCH_w_8_72 & 0xff) /* i8 at 72 */, 8);
38592       nextPC = 10 + MATCH_p; 
38593       
38594 #line 1349 "frontend/machine/pentium/decoder.m"
38595       
38596 
38597             stmts = instantiate(pc,  "BTiow", DIS_EADDR16, DIS_I8);
38598 
38599       
38600 
38601       
38602       
38603       
38604     } 
38605     goto MATCH_finished_c; 
38606     
38607   MATCH_label_c124: (void)0; /*placeholder for label*/ 
38608     { 
38609       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38610       int /* [~128..127] */ i8 = 
38611         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
38612       nextPC = 9 + MATCH_p; 
38613       
38614 #line 1349 "frontend/machine/pentium/decoder.m"
38615       
38616 
38617             stmts = instantiate(pc,  "BTiow", DIS_EADDR16, DIS_I8);
38618 
38619       
38620 
38621       
38622       
38623       
38624     } 
38625     goto MATCH_finished_c; 
38626     
38627   MATCH_label_c125: (void)0; /*placeholder for label*/ 
38628     { 
38629       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38630       int /* [~128..127] */ i8 = 
38631         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
38632       nextPC = 5 + MATCH_p; 
38633       
38634 #line 1313 "frontend/machine/pentium/decoder.m"
38635       
38636 
38637             stmts = instantiate(pc,  "BTSiow", DIS_I8, DIS_EADDR16);
38638 
38639       
38640 
38641       
38642       
38643       
38644     } 
38645     goto MATCH_finished_c; 
38646     
38647   MATCH_label_c126: (void)0; /*placeholder for label*/ 
38648     { 
38649       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38650       int /* [~128..127] */ i8 = 
38651         sign_extend((MATCH_w_8_40 & 0xff) /* i8 at 40 */, 8);
38652       nextPC = 6 + MATCH_p; 
38653       
38654 #line 1313 "frontend/machine/pentium/decoder.m"
38655       
38656 
38657             stmts = instantiate(pc,  "BTSiow", DIS_I8, DIS_EADDR16);
38658 
38659       
38660 
38661       
38662       
38663       
38664     } 
38665     goto MATCH_finished_c; 
38666     
38667   MATCH_label_c127: (void)0; /*placeholder for label*/ 
38668     { 
38669       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38670       int /* [~128..127] */ i8 = 
38671         sign_extend((MATCH_w_8_72 & 0xff) /* i8 at 72 */, 8);
38672       nextPC = 10 + MATCH_p; 
38673       
38674 #line 1313 "frontend/machine/pentium/decoder.m"
38675       
38676 
38677             stmts = instantiate(pc,  "BTSiow", DIS_I8, DIS_EADDR16);
38678 
38679       
38680 
38681       
38682       
38683       
38684     } 
38685     goto MATCH_finished_c; 
38686     
38687   MATCH_label_c128: (void)0; /*placeholder for label*/ 
38688     { 
38689       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38690       int /* [~128..127] */ i8 = 
38691         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
38692       nextPC = 9 + MATCH_p; 
38693       
38694 #line 1313 "frontend/machine/pentium/decoder.m"
38695       
38696 
38697             stmts = instantiate(pc,  "BTSiow", DIS_I8, DIS_EADDR16);
38698 
38699       
38700 
38701       
38702       
38703       
38704     } 
38705     goto MATCH_finished_c; 
38706     
38707   MATCH_label_c129: (void)0; /*placeholder for label*/ 
38708     { 
38709       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38710       int /* [~128..127] */ i8 = 
38711         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
38712       nextPC = 5 + MATCH_p; 
38713       
38714 #line 1325 "frontend/machine/pentium/decoder.m"
38715       
38716 
38717             stmts = instantiate(pc,  "BTRiow", DIS_EADDR16, DIS_I8);
38718 
38719       
38720 
38721       
38722       
38723       
38724     } 
38725     goto MATCH_finished_c; 
38726     
38727   MATCH_label_c130: (void)0; /*placeholder for label*/ 
38728     { 
38729       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38730       int /* [~128..127] */ i8 = 
38731         sign_extend((MATCH_w_8_40 & 0xff) /* i8 at 40 */, 8);
38732       nextPC = 6 + MATCH_p; 
38733       
38734 #line 1325 "frontend/machine/pentium/decoder.m"
38735       
38736 
38737             stmts = instantiate(pc,  "BTRiow", DIS_EADDR16, DIS_I8);
38738 
38739       
38740 
38741       
38742       
38743       
38744     } 
38745     goto MATCH_finished_c; 
38746     
38747   MATCH_label_c131: (void)0; /*placeholder for label*/ 
38748     { 
38749       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38750       int /* [~128..127] */ i8 = 
38751         sign_extend((MATCH_w_8_72 & 0xff) /* i8 at 72 */, 8);
38752       nextPC = 10 + MATCH_p; 
38753       
38754 #line 1325 "frontend/machine/pentium/decoder.m"
38755       
38756 
38757             stmts = instantiate(pc,  "BTRiow", DIS_EADDR16, DIS_I8);
38758 
38759       
38760 
38761       
38762       
38763       
38764     } 
38765     goto MATCH_finished_c; 
38766     
38767   MATCH_label_c132: (void)0; /*placeholder for label*/ 
38768     { 
38769       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38770       int /* [~128..127] */ i8 = 
38771         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
38772       nextPC = 9 + MATCH_p; 
38773       
38774 #line 1325 "frontend/machine/pentium/decoder.m"
38775       
38776 
38777             stmts = instantiate(pc,  "BTRiow", DIS_EADDR16, DIS_I8);
38778 
38779       
38780 
38781       
38782       
38783       
38784     } 
38785     goto MATCH_finished_c; 
38786     
38787   MATCH_label_c133: (void)0; /*placeholder for label*/ 
38788     { 
38789       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38790       int /* [~128..127] */ i8 = 
38791         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
38792       nextPC = 5 + MATCH_p; 
38793       
38794 #line 1337 "frontend/machine/pentium/decoder.m"
38795       
38796 
38797             stmts = instantiate(pc,  "BTCiow", DIS_EADDR16, DIS_I8);
38798 
38799       
38800 
38801       
38802       
38803       
38804     } 
38805     goto MATCH_finished_c; 
38806     
38807   MATCH_label_c134: (void)0; /*placeholder for label*/ 
38808     { 
38809       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38810       int /* [~128..127] */ i8 = 
38811         sign_extend((MATCH_w_8_40 & 0xff) /* i8 at 40 */, 8);
38812       nextPC = 6 + MATCH_p; 
38813       
38814 #line 1337 "frontend/machine/pentium/decoder.m"
38815       
38816 
38817             stmts = instantiate(pc,  "BTCiow", DIS_EADDR16, DIS_I8);
38818 
38819       
38820 
38821       
38822       
38823       
38824     } 
38825     goto MATCH_finished_c; 
38826     
38827   MATCH_label_c135: (void)0; /*placeholder for label*/ 
38828     { 
38829       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38830       int /* [~128..127] */ i8 = 
38831         sign_extend((MATCH_w_8_72 & 0xff) /* i8 at 72 */, 8);
38832       nextPC = 10 + MATCH_p; 
38833       
38834 #line 1337 "frontend/machine/pentium/decoder.m"
38835       
38836 
38837             stmts = instantiate(pc,  "BTCiow", DIS_EADDR16, DIS_I8);
38838 
38839       
38840 
38841       
38842       
38843       
38844     } 
38845     goto MATCH_finished_c; 
38846     
38847   MATCH_label_c136: (void)0; /*placeholder for label*/ 
38848     { 
38849       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38850       int /* [~128..127] */ i8 = 
38851         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
38852       nextPC = 9 + MATCH_p; 
38853       
38854 #line 1337 "frontend/machine/pentium/decoder.m"
38855       
38856 
38857             stmts = instantiate(pc,  "BTCiow", DIS_EADDR16, DIS_I8);
38858 
38859       
38860 
38861       
38862       
38863       
38864     } 
38865     goto MATCH_finished_c; 
38866     
38867   MATCH_label_c137: (void)0; /*placeholder for label*/ 
38868     { 
38869       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38870       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38871       nextPC = 4 + MATCH_p; 
38872       
38873 #line 1331 "frontend/machine/pentium/decoder.m"
38874       
38875 
38876             stmts = instantiate(pc,  "BTRow", DIS_EADDR16, DIS_REG16);
38877 
38878       
38879 
38880       
38881       
38882       
38883     } 
38884     goto MATCH_finished_c; 
38885     
38886   MATCH_label_c138: (void)0; /*placeholder for label*/ 
38887     { 
38888       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38889       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38890       nextPC = 5 + MATCH_p; 
38891       
38892 #line 1331 "frontend/machine/pentium/decoder.m"
38893       
38894 
38895             stmts = instantiate(pc,  "BTRow", DIS_EADDR16, DIS_REG16);
38896 
38897       
38898 
38899       
38900       
38901       
38902     } 
38903     goto MATCH_finished_c; 
38904     
38905   MATCH_label_c139: (void)0; /*placeholder for label*/ 
38906     { 
38907       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38908       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38909       nextPC = 9 + MATCH_p; 
38910       
38911 #line 1331 "frontend/machine/pentium/decoder.m"
38912       
38913 
38914             stmts = instantiate(pc,  "BTRow", DIS_EADDR16, DIS_REG16);
38915 
38916       
38917 
38918       
38919       
38920       
38921     } 
38922     goto MATCH_finished_c; 
38923     
38924   MATCH_label_c140: (void)0; /*placeholder for label*/ 
38925     { 
38926       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38927       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38928       nextPC = 8 + MATCH_p; 
38929       
38930 #line 1331 "frontend/machine/pentium/decoder.m"
38931       
38932 
38933             stmts = instantiate(pc,  "BTRow", DIS_EADDR16, DIS_REG16);
38934 
38935       
38936 
38937       
38938       
38939       
38940     } 
38941     goto MATCH_finished_c; 
38942     
38943   MATCH_label_c141: (void)0; /*placeholder for label*/ 
38944     { 
38945       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38946       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38947       nextPC = 4 + MATCH_p; 
38948       
38949 #line 1343 "frontend/machine/pentium/decoder.m"
38950       
38951 
38952             stmts = instantiate(pc,  "BTCow", DIS_EADDR16, DIS_REG16);
38953 
38954       
38955 
38956       
38957       
38958       
38959     } 
38960     goto MATCH_finished_c; 
38961     
38962   MATCH_label_c142: (void)0; /*placeholder for label*/ 
38963     { 
38964       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38965       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38966       nextPC = 5 + MATCH_p; 
38967       
38968 #line 1343 "frontend/machine/pentium/decoder.m"
38969       
38970 
38971             stmts = instantiate(pc,  "BTCow", DIS_EADDR16, DIS_REG16);
38972 
38973       
38974 
38975       
38976       
38977       
38978     } 
38979     goto MATCH_finished_c; 
38980     
38981   MATCH_label_c143: (void)0; /*placeholder for label*/ 
38982     { 
38983       unsigned Eaddr = 3 + addressToPC(MATCH_p);
38984       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
38985       nextPC = 9 + MATCH_p; 
38986       
38987 #line 1343 "frontend/machine/pentium/decoder.m"
38988       
38989 
38990             stmts = instantiate(pc,  "BTCow", DIS_EADDR16, DIS_REG16);
38991 
38992       
38993 
38994       
38995       
38996       
38997     } 
38998     goto MATCH_finished_c; 
38999     
39000   MATCH_label_c144: (void)0; /*placeholder for label*/ 
39001     { 
39002       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39003       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39004       nextPC = 8 + MATCH_p; 
39005       
39006 #line 1343 "frontend/machine/pentium/decoder.m"
39007       
39008 
39009             stmts = instantiate(pc,  "BTCow", DIS_EADDR16, DIS_REG16);
39010 
39011       
39012 
39013       
39014       
39015       
39016     } 
39017     goto MATCH_finished_c; 
39018     
39019   MATCH_label_c145: (void)0; /*placeholder for label*/ 
39020     { 
39021       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39022       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39023       nextPC = 4 + MATCH_p; 
39024       
39025 #line 1377 "frontend/machine/pentium/decoder.m"
39026       
39027 
39028             //stmts = instantiate(pc,  "BSFow", DIS_REG16, DIS_EADDR16);
39029 
39030             genBSFR(pc, DIS_REG16, DIS_EADDR16, -1, 16, opPlus, nextPC-hostPC);
39031 
39032             return result;
39033 
39034       
39035 
39036         // Not "user" instructions:
39037 
39038       //    | BOUNDod(reg, Mem) =>
39039 
39040       //        stmts = instantiate(pc,  "BOUNDod", DIS_REG32, DIS_MEM);
39041 
39042       
39043 
39044       //    | BOUNDow(reg, Mem) =>
39045 
39046       //        stmts = instantiate(pc,  "BOUNDow", DIS_REG16, DIS_MEM);
39047 
39048       
39049 
39050       //      | ARPL(Eaddr, reg ) =>
39051 
39052       //          unused(Eaddr); unused(reg);
39053 
39054       //          stmts = instantiate(pc,  "UNIMP");
39055 
39056       
39057 
39058       //      | AAS() =>
39059 
39060       //          stmts = instantiate(pc,  "AAS");
39061 
39062       
39063 
39064       //      | AAM() =>
39065 
39066       //          stmts = instantiate(pc,  "AAM");
39067 
39068       
39069 
39070       //      | AAD() =>
39071 
39072       //          stmts = instantiate(pc,  "AAD");
39073 
39074       
39075 
39076       //      | AAA() =>
39077 
39078       //          stmts = instantiate(pc,  "AAA");
39079 
39080       
39081 
39082       
39083       
39084       
39085     } 
39086     goto MATCH_finished_c; 
39087     
39088   MATCH_label_c146: (void)0; /*placeholder for label*/ 
39089     { 
39090       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39091       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39092       nextPC = 5 + MATCH_p; 
39093       
39094 #line 1377 "frontend/machine/pentium/decoder.m"
39095       
39096 
39097             //stmts = instantiate(pc,  "BSFow", DIS_REG16, DIS_EADDR16);
39098 
39099             genBSFR(pc, DIS_REG16, DIS_EADDR16, -1, 16, opPlus, nextPC-hostPC);
39100 
39101             return result;
39102 
39103       
39104 
39105         // Not "user" instructions:
39106 
39107       //    | BOUNDod(reg, Mem) =>
39108 
39109       //        stmts = instantiate(pc,  "BOUNDod", DIS_REG32, DIS_MEM);
39110 
39111       
39112 
39113       //    | BOUNDow(reg, Mem) =>
39114 
39115       //        stmts = instantiate(pc,  "BOUNDow", DIS_REG16, DIS_MEM);
39116 
39117       
39118 
39119       //      | ARPL(Eaddr, reg ) =>
39120 
39121       //          unused(Eaddr); unused(reg);
39122 
39123       //          stmts = instantiate(pc,  "UNIMP");
39124 
39125       
39126 
39127       //      | AAS() =>
39128 
39129       //          stmts = instantiate(pc,  "AAS");
39130 
39131       
39132 
39133       //      | AAM() =>
39134 
39135       //          stmts = instantiate(pc,  "AAM");
39136 
39137       
39138 
39139       //      | AAD() =>
39140 
39141       //          stmts = instantiate(pc,  "AAD");
39142 
39143       
39144 
39145       //      | AAA() =>
39146 
39147       //          stmts = instantiate(pc,  "AAA");
39148 
39149       
39150 
39151       
39152       
39153       
39154     } 
39155     goto MATCH_finished_c; 
39156     
39157   MATCH_label_c147: (void)0; /*placeholder for label*/ 
39158     { 
39159       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39160       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39161       nextPC = 9 + MATCH_p; 
39162       
39163 #line 1377 "frontend/machine/pentium/decoder.m"
39164       
39165 
39166             //stmts = instantiate(pc,  "BSFow", DIS_REG16, DIS_EADDR16);
39167 
39168             genBSFR(pc, DIS_REG16, DIS_EADDR16, -1, 16, opPlus, nextPC-hostPC);
39169 
39170             return result;
39171 
39172       
39173 
39174         // Not "user" instructions:
39175 
39176       //    | BOUNDod(reg, Mem) =>
39177 
39178       //        stmts = instantiate(pc,  "BOUNDod", DIS_REG32, DIS_MEM);
39179 
39180       
39181 
39182       //    | BOUNDow(reg, Mem) =>
39183 
39184       //        stmts = instantiate(pc,  "BOUNDow", DIS_REG16, DIS_MEM);
39185 
39186       
39187 
39188       //      | ARPL(Eaddr, reg ) =>
39189 
39190       //          unused(Eaddr); unused(reg);
39191 
39192       //          stmts = instantiate(pc,  "UNIMP");
39193 
39194       
39195 
39196       //      | AAS() =>
39197 
39198       //          stmts = instantiate(pc,  "AAS");
39199 
39200       
39201 
39202       //      | AAM() =>
39203 
39204       //          stmts = instantiate(pc,  "AAM");
39205 
39206       
39207 
39208       //      | AAD() =>
39209 
39210       //          stmts = instantiate(pc,  "AAD");
39211 
39212       
39213 
39214       //      | AAA() =>
39215 
39216       //          stmts = instantiate(pc,  "AAA");
39217 
39218       
39219 
39220       
39221       
39222       
39223     } 
39224     goto MATCH_finished_c; 
39225     
39226   MATCH_label_c148: (void)0; /*placeholder for label*/ 
39227     { 
39228       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39229       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39230       nextPC = 8 + MATCH_p; 
39231       
39232 #line 1377 "frontend/machine/pentium/decoder.m"
39233       
39234 
39235             //stmts = instantiate(pc,  "BSFow", DIS_REG16, DIS_EADDR16);
39236 
39237             genBSFR(pc, DIS_REG16, DIS_EADDR16, -1, 16, opPlus, nextPC-hostPC);
39238 
39239             return result;
39240 
39241       
39242 
39243         // Not "user" instructions:
39244 
39245       //    | BOUNDod(reg, Mem) =>
39246 
39247       //        stmts = instantiate(pc,  "BOUNDod", DIS_REG32, DIS_MEM);
39248 
39249       
39250 
39251       //    | BOUNDow(reg, Mem) =>
39252 
39253       //        stmts = instantiate(pc,  "BOUNDow", DIS_REG16, DIS_MEM);
39254 
39255       
39256 
39257       //      | ARPL(Eaddr, reg ) =>
39258 
39259       //          unused(Eaddr); unused(reg);
39260 
39261       //          stmts = instantiate(pc,  "UNIMP");
39262 
39263       
39264 
39265       //      | AAS() =>
39266 
39267       //          stmts = instantiate(pc,  "AAS");
39268 
39269       
39270 
39271       //      | AAM() =>
39272 
39273       //          stmts = instantiate(pc,  "AAM");
39274 
39275       
39276 
39277       //      | AAD() =>
39278 
39279       //          stmts = instantiate(pc,  "AAD");
39280 
39281       
39282 
39283       //      | AAA() =>
39284 
39285       //          stmts = instantiate(pc,  "AAA");
39286 
39287       
39288 
39289       
39290       
39291       
39292     } 
39293     goto MATCH_finished_c; 
39294     
39295   MATCH_label_c149: (void)0; /*placeholder for label*/ 
39296     { 
39297       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39298       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39299       nextPC = 4 + MATCH_p; 
39300       
39301 #line 1367 "frontend/machine/pentium/decoder.m"
39302       
39303 
39304             //stmts = instantiate(pc,  "BSRow", DIS_REG16, DIS_EADDR16);
39305 
39306             genBSFR(pc, DIS_REG16, DIS_EADDR16, 16, 16, opMinus, nextPC-hostPC);
39307 
39308             return result;
39309 
39310       
39311 
39312       
39313       
39314       
39315     } 
39316     goto MATCH_finished_c; 
39317     
39318   MATCH_label_c150: (void)0; /*placeholder for label*/ 
39319     { 
39320       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39321       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39322       nextPC = 5 + MATCH_p; 
39323       
39324 #line 1367 "frontend/machine/pentium/decoder.m"
39325       
39326 
39327             //stmts = instantiate(pc,  "BSRow", DIS_REG16, DIS_EADDR16);
39328 
39329             genBSFR(pc, DIS_REG16, DIS_EADDR16, 16, 16, opMinus, nextPC-hostPC);
39330 
39331             return result;
39332 
39333       
39334 
39335       
39336       
39337       
39338     } 
39339     goto MATCH_finished_c; 
39340     
39341   MATCH_label_c151: (void)0; /*placeholder for label*/ 
39342     { 
39343       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39344       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39345       nextPC = 9 + MATCH_p; 
39346       
39347 #line 1367 "frontend/machine/pentium/decoder.m"
39348       
39349 
39350             //stmts = instantiate(pc,  "BSRow", DIS_REG16, DIS_EADDR16);
39351 
39352             genBSFR(pc, DIS_REG16, DIS_EADDR16, 16, 16, opMinus, nextPC-hostPC);
39353 
39354             return result;
39355 
39356       
39357 
39358       
39359       
39360       
39361     } 
39362     goto MATCH_finished_c; 
39363     
39364   MATCH_label_c152: (void)0; /*placeholder for label*/ 
39365     { 
39366       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39367       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39368       nextPC = 8 + MATCH_p; 
39369       
39370 #line 1367 "frontend/machine/pentium/decoder.m"
39371       
39372 
39373             //stmts = instantiate(pc,  "BSRow", DIS_REG16, DIS_EADDR16);
39374 
39375             genBSFR(pc, DIS_REG16, DIS_EADDR16, 16, 16, opMinus, nextPC-hostPC);
39376 
39377             return result;
39378 
39379       
39380 
39381       
39382       
39383       
39384     } 
39385     goto MATCH_finished_c; 
39386     
39387   MATCH_label_c153: (void)0; /*placeholder for label*/ 
39388     { 
39389       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39390       unsigned r16 = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39391       nextPC = 4 + MATCH_p; 
39392       
39393 #line 943 "frontend/machine/pentium/decoder.m"
39394       
39395 
39396             stmts = instantiate(pc,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
39397 
39398       
39399 
39400       
39401       
39402       
39403     } 
39404     goto MATCH_finished_c; 
39405     
39406   MATCH_label_c154: (void)0; /*placeholder for label*/ 
39407     { 
39408       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39409       unsigned r16 = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39410       nextPC = 5 + MATCH_p; 
39411       
39412 #line 943 "frontend/machine/pentium/decoder.m"
39413       
39414 
39415             stmts = instantiate(pc,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
39416 
39417       
39418 
39419       
39420       
39421       
39422     } 
39423     goto MATCH_finished_c; 
39424     
39425   MATCH_label_c155: (void)0; /*placeholder for label*/ 
39426     { 
39427       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39428       unsigned r16 = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39429       nextPC = 9 + MATCH_p; 
39430       
39431 #line 943 "frontend/machine/pentium/decoder.m"
39432       
39433 
39434             stmts = instantiate(pc,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
39435 
39436       
39437 
39438       
39439       
39440       
39441     } 
39442     goto MATCH_finished_c; 
39443     
39444   MATCH_label_c156: (void)0; /*placeholder for label*/ 
39445     { 
39446       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39447       unsigned r16 = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39448       nextPC = 8 + MATCH_p; 
39449       
39450 #line 943 "frontend/machine/pentium/decoder.m"
39451       
39452 
39453             stmts = instantiate(pc,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
39454 
39455       
39456 
39457       
39458       
39459       
39460     } 
39461     goto MATCH_finished_c; 
39462     
39463   MATCH_label_c157: (void)0; /*placeholder for label*/ 
39464     { 
39465       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39466       unsigned r16 = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39467       nextPC = 4 + MATCH_p; 
39468       
39469 #line 952 "frontend/machine/pentium/decoder.m"
39470       
39471 
39472             stmts = instantiate(pc,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
39473 
39474       
39475 
39476       
39477       
39478       
39479     } 
39480     goto MATCH_finished_c; 
39481     
39482   MATCH_label_c158: (void)0; /*placeholder for label*/ 
39483     { 
39484       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39485       unsigned r16 = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39486       nextPC = 5 + MATCH_p; 
39487       
39488 #line 952 "frontend/machine/pentium/decoder.m"
39489       
39490 
39491             stmts = instantiate(pc,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
39492 
39493       
39494 
39495       
39496       
39497       
39498     } 
39499     goto MATCH_finished_c; 
39500     
39501   MATCH_label_c159: (void)0; /*placeholder for label*/ 
39502     { 
39503       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39504       unsigned r16 = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39505       nextPC = 9 + MATCH_p; 
39506       
39507 #line 952 "frontend/machine/pentium/decoder.m"
39508       
39509 
39510             stmts = instantiate(pc,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
39511 
39512       
39513 
39514       
39515       
39516       
39517     } 
39518     goto MATCH_finished_c; 
39519     
39520   MATCH_label_c160: (void)0; /*placeholder for label*/ 
39521     { 
39522       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39523       unsigned r16 = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39524       nextPC = 8 + MATCH_p; 
39525       
39526 #line 952 "frontend/machine/pentium/decoder.m"
39527       
39528 
39529             stmts = instantiate(pc,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
39530 
39531       
39532 
39533       
39534       
39535       
39536     } 
39537     goto MATCH_finished_c; 
39538     
39539   MATCH_label_c161: (void)0; /*placeholder for label*/ 
39540     { 
39541       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39542       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39543       nextPC = 4 + MATCH_p; 
39544       
39545 #line 357 "frontend/machine/pentium/decoder.m"
39546       
39547 
39548             stmts = instantiate(pc,  "XADD.Ev.Gvow", DIS_EADDR16, DIS_REG16);
39549 
39550       
39551 
39552       
39553       
39554       
39555     } 
39556     goto MATCH_finished_c; 
39557     
39558   MATCH_label_c162: (void)0; /*placeholder for label*/ 
39559     { 
39560       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39561       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39562       nextPC = 5 + MATCH_p; 
39563       
39564 #line 357 "frontend/machine/pentium/decoder.m"
39565       
39566 
39567             stmts = instantiate(pc,  "XADD.Ev.Gvow", DIS_EADDR16, DIS_REG16);
39568 
39569       
39570 
39571       
39572       
39573       
39574     } 
39575     goto MATCH_finished_c; 
39576     
39577   MATCH_label_c163: (void)0; /*placeholder for label*/ 
39578     { 
39579       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39580       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39581       nextPC = 9 + MATCH_p; 
39582       
39583 #line 357 "frontend/machine/pentium/decoder.m"
39584       
39585 
39586             stmts = instantiate(pc,  "XADD.Ev.Gvow", DIS_EADDR16, DIS_REG16);
39587 
39588       
39589 
39590       
39591       
39592       
39593     } 
39594     goto MATCH_finished_c; 
39595     
39596   MATCH_label_c164: (void)0; /*placeholder for label*/ 
39597     { 
39598       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39599       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39600       nextPC = 8 + MATCH_p; 
39601       
39602 #line 357 "frontend/machine/pentium/decoder.m"
39603       
39604 
39605             stmts = instantiate(pc,  "XADD.Ev.Gvow", DIS_EADDR16, DIS_REG16);
39606 
39607       
39608 
39609       
39610       
39611       
39612     } 
39613     goto MATCH_finished_c; 
39614     
39615   MATCH_label_c165: (void)0; /*placeholder for label*/ 
39616     { 
39617       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39618       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39619       nextPC = 3 + MATCH_p; 
39620       
39621 #line 1510 "frontend/machine/pentium/decoder.m"
39622       
39623 
39624             stmts = instantiate(pc,  "ADCmrow", DIS_EADDR16, DIS_REG16);
39625 
39626       
39627 
39628       
39629       
39630       
39631     } 
39632     goto MATCH_finished_c; 
39633     
39634   MATCH_label_c166: (void)0; /*placeholder for label*/ 
39635     { 
39636       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39637       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39638       nextPC = 4 + MATCH_p; 
39639       
39640 #line 1510 "frontend/machine/pentium/decoder.m"
39641       
39642 
39643             stmts = instantiate(pc,  "ADCmrow", DIS_EADDR16, DIS_REG16);
39644 
39645       
39646 
39647       
39648       
39649       
39650     } 
39651     goto MATCH_finished_c; 
39652     
39653   MATCH_label_c167: (void)0; /*placeholder for label*/ 
39654     { 
39655       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39656       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39657       nextPC = 8 + MATCH_p; 
39658       
39659 #line 1510 "frontend/machine/pentium/decoder.m"
39660       
39661 
39662             stmts = instantiate(pc,  "ADCmrow", DIS_EADDR16, DIS_REG16);
39663 
39664       
39665 
39666       
39667       
39668       
39669     } 
39670     goto MATCH_finished_c; 
39671     
39672   MATCH_label_c168: (void)0; /*placeholder for label*/ 
39673     { 
39674       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39675       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39676       nextPC = 7 + MATCH_p; 
39677       
39678 #line 1510 "frontend/machine/pentium/decoder.m"
39679       
39680 
39681             stmts = instantiate(pc,  "ADCmrow", DIS_EADDR16, DIS_REG16);
39682 
39683       
39684 
39685       
39686       
39687       
39688     } 
39689     goto MATCH_finished_c; 
39690     
39691   MATCH_label_c169: (void)0; /*placeholder for label*/ 
39692     { 
39693       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39694       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39695       nextPC = 3 + MATCH_p; 
39696       
39697 #line 1504 "frontend/machine/pentium/decoder.m"
39698       
39699 
39700             stmts = instantiate(pc,  "SBBmrow", DIS_EADDR16, DIS_REG16);
39701 
39702       
39703 
39704       
39705       
39706       
39707     } 
39708     goto MATCH_finished_c; 
39709     
39710   MATCH_label_c170: (void)0; /*placeholder for label*/ 
39711     { 
39712       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39713       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39714       nextPC = 4 + MATCH_p; 
39715       
39716 #line 1504 "frontend/machine/pentium/decoder.m"
39717       
39718 
39719             stmts = instantiate(pc,  "SBBmrow", DIS_EADDR16, DIS_REG16);
39720 
39721       
39722 
39723       
39724       
39725       
39726     } 
39727     goto MATCH_finished_c; 
39728     
39729   MATCH_label_c171: (void)0; /*placeholder for label*/ 
39730     { 
39731       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39732       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39733       nextPC = 8 + MATCH_p; 
39734       
39735 #line 1504 "frontend/machine/pentium/decoder.m"
39736       
39737 
39738             stmts = instantiate(pc,  "SBBmrow", DIS_EADDR16, DIS_REG16);
39739 
39740       
39741 
39742       
39743       
39744       
39745     } 
39746     goto MATCH_finished_c; 
39747     
39748   MATCH_label_c172: (void)0; /*placeholder for label*/ 
39749     { 
39750       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39751       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39752       nextPC = 7 + MATCH_p; 
39753       
39754 #line 1504 "frontend/machine/pentium/decoder.m"
39755       
39756 
39757             stmts = instantiate(pc,  "SBBmrow", DIS_EADDR16, DIS_REG16);
39758 
39759       
39760 
39761       
39762       
39763       
39764     } 
39765     goto MATCH_finished_c; 
39766     
39767   MATCH_label_c173: (void)0; /*placeholder for label*/ 
39768     { 
39769       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39770       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39771       nextPC = 3 + MATCH_p; 
39772       
39773 #line 1438 "frontend/machine/pentium/decoder.m"
39774       
39775 
39776             stmts = instantiate(pc,  "ADCrmow", DIS_REG16, DIS_EADDR16);
39777 
39778       
39779 
39780       
39781       
39782       
39783     } 
39784     goto MATCH_finished_c; 
39785     
39786   MATCH_label_c174: (void)0; /*placeholder for label*/ 
39787     { 
39788       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39789       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39790       nextPC = 4 + MATCH_p; 
39791       
39792 #line 1438 "frontend/machine/pentium/decoder.m"
39793       
39794 
39795             stmts = instantiate(pc,  "ADCrmow", DIS_REG16, DIS_EADDR16);
39796 
39797       
39798 
39799       
39800       
39801       
39802     } 
39803     goto MATCH_finished_c; 
39804     
39805   MATCH_label_c175: (void)0; /*placeholder for label*/ 
39806     { 
39807       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39808       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39809       nextPC = 8 + MATCH_p; 
39810       
39811 #line 1438 "frontend/machine/pentium/decoder.m"
39812       
39813 
39814             stmts = instantiate(pc,  "ADCrmow", DIS_REG16, DIS_EADDR16);
39815 
39816       
39817 
39818       
39819       
39820       
39821     } 
39822     goto MATCH_finished_c; 
39823     
39824   MATCH_label_c176: (void)0; /*placeholder for label*/ 
39825     { 
39826       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39827       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39828       nextPC = 7 + MATCH_p; 
39829       
39830 #line 1438 "frontend/machine/pentium/decoder.m"
39831       
39832 
39833             stmts = instantiate(pc,  "ADCrmow", DIS_REG16, DIS_EADDR16);
39834 
39835       
39836 
39837       
39838       
39839       
39840     } 
39841     goto MATCH_finished_c; 
39842     
39843   MATCH_label_c177: (void)0; /*placeholder for label*/ 
39844     { 
39845       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39846       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39847       nextPC = 3 + MATCH_p; 
39848       
39849 #line 1432 "frontend/machine/pentium/decoder.m"
39850       
39851 
39852             stmts = instantiate(pc,  "SBBrmow", DIS_REG16, DIS_EADDR16);
39853 
39854       
39855 
39856       
39857       
39858       
39859     } 
39860     goto MATCH_finished_c; 
39861     
39862   MATCH_label_c178: (void)0; /*placeholder for label*/ 
39863     { 
39864       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39865       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39866       nextPC = 4 + MATCH_p; 
39867       
39868 #line 1432 "frontend/machine/pentium/decoder.m"
39869       
39870 
39871             stmts = instantiate(pc,  "SBBrmow", DIS_REG16, DIS_EADDR16);
39872 
39873       
39874 
39875       
39876       
39877       
39878     } 
39879     goto MATCH_finished_c; 
39880     
39881   MATCH_label_c179: (void)0; /*placeholder for label*/ 
39882     { 
39883       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39884       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39885       nextPC = 8 + MATCH_p; 
39886       
39887 #line 1432 "frontend/machine/pentium/decoder.m"
39888       
39889 
39890             stmts = instantiate(pc,  "SBBrmow", DIS_REG16, DIS_EADDR16);
39891 
39892       
39893 
39894       
39895       
39896       
39897     } 
39898     goto MATCH_finished_c; 
39899     
39900   MATCH_label_c180: (void)0; /*placeholder for label*/ 
39901     { 
39902       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39903       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39904       nextPC = 7 + MATCH_p; 
39905       
39906 #line 1432 "frontend/machine/pentium/decoder.m"
39907       
39908 
39909             stmts = instantiate(pc,  "SBBrmow", DIS_REG16, DIS_EADDR16);
39910 
39911       
39912 
39913       
39914       
39915       
39916     } 
39917     goto MATCH_finished_c; 
39918     
39919   MATCH_label_c181: (void)0; /*placeholder for label*/ 
39920     { 
39921       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39922       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39923       nextPC = 3 + MATCH_p; 
39924       
39925 #line 1498 "frontend/machine/pentium/decoder.m"
39926       
39927 
39928             stmts = instantiate(pc,  "ANDmrow", DIS_EADDR16, DIS_REG16);
39929 
39930       
39931 
39932       
39933       
39934       
39935     } 
39936     goto MATCH_finished_c; 
39937     
39938   MATCH_label_c182: (void)0; /*placeholder for label*/ 
39939     { 
39940       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39941       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39942       nextPC = 4 + MATCH_p; 
39943       
39944 #line 1498 "frontend/machine/pentium/decoder.m"
39945       
39946 
39947             stmts = instantiate(pc,  "ANDmrow", DIS_EADDR16, DIS_REG16);
39948 
39949       
39950 
39951       
39952       
39953       
39954     } 
39955     goto MATCH_finished_c; 
39956     
39957   MATCH_label_c183: (void)0; /*placeholder for label*/ 
39958     { 
39959       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39960       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39961       nextPC = 8 + MATCH_p; 
39962       
39963 #line 1498 "frontend/machine/pentium/decoder.m"
39964       
39965 
39966             stmts = instantiate(pc,  "ANDmrow", DIS_EADDR16, DIS_REG16);
39967 
39968       
39969 
39970       
39971       
39972       
39973     } 
39974     goto MATCH_finished_c; 
39975     
39976   MATCH_label_c184: (void)0; /*placeholder for label*/ 
39977     { 
39978       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39979       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39980       nextPC = 7 + MATCH_p; 
39981       
39982 #line 1498 "frontend/machine/pentium/decoder.m"
39983       
39984 
39985             stmts = instantiate(pc,  "ANDmrow", DIS_EADDR16, DIS_REG16);
39986 
39987       
39988 
39989       
39990       
39991       
39992     } 
39993     goto MATCH_finished_c; 
39994     
39995   MATCH_label_c185: (void)0; /*placeholder for label*/ 
39996     { 
39997       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39998       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39999       nextPC = 3 + MATCH_p; 
40000       
40001 #line 1492 "frontend/machine/pentium/decoder.m"
40002       
40003 
40004             stmts = instantiate(pc,  "SUBmrow", DIS_EADDR16, DIS_REG16);
40005 
40006       
40007 
40008       
40009       
40010       
40011     } 
40012     goto MATCH_finished_c; 
40013     
40014   MATCH_label_c186: (void)0; /*placeholder for label*/ 
40015     { 
40016       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40017       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40018       nextPC = 4 + MATCH_p; 
40019       
40020 #line 1492 "frontend/machine/pentium/decoder.m"
40021       
40022 
40023             stmts = instantiate(pc,  "SUBmrow", DIS_EADDR16, DIS_REG16);
40024 
40025       
40026 
40027       
40028       
40029       
40030     } 
40031     goto MATCH_finished_c; 
40032     
40033   MATCH_label_c187: (void)0; /*placeholder for label*/ 
40034     { 
40035       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40036       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40037       nextPC = 8 + MATCH_p; 
40038       
40039 #line 1492 "frontend/machine/pentium/decoder.m"
40040       
40041 
40042             stmts = instantiate(pc,  "SUBmrow", DIS_EADDR16, DIS_REG16);
40043 
40044       
40045 
40046       
40047       
40048       
40049     } 
40050     goto MATCH_finished_c; 
40051     
40052   MATCH_label_c188: (void)0; /*placeholder for label*/ 
40053     { 
40054       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40055       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40056       nextPC = 7 + MATCH_p; 
40057       
40058 #line 1492 "frontend/machine/pentium/decoder.m"
40059       
40060 
40061             stmts = instantiate(pc,  "SUBmrow", DIS_EADDR16, DIS_REG16);
40062 
40063       
40064 
40065       
40066       
40067       
40068     } 
40069     goto MATCH_finished_c; 
40070     
40071   MATCH_label_c189: (void)0; /*placeholder for label*/ 
40072     { 
40073       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40074       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40075       nextPC = 3 + MATCH_p; 
40076       
40077 #line 1426 "frontend/machine/pentium/decoder.m"
40078       
40079 
40080             stmts = instantiate(pc,  "ANDrmow", DIS_REG16, DIS_EADDR16);
40081 
40082       
40083 
40084       
40085       
40086       
40087     } 
40088     goto MATCH_finished_c; 
40089     
40090   MATCH_label_c190: (void)0; /*placeholder for label*/ 
40091     { 
40092       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40093       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40094       nextPC = 4 + MATCH_p; 
40095       
40096 #line 1426 "frontend/machine/pentium/decoder.m"
40097       
40098 
40099             stmts = instantiate(pc,  "ANDrmow", DIS_REG16, DIS_EADDR16);
40100 
40101       
40102 
40103       
40104       
40105       
40106     } 
40107     goto MATCH_finished_c; 
40108     
40109   MATCH_label_c191: (void)0; /*placeholder for label*/ 
40110     { 
40111       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40112       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40113       nextPC = 8 + MATCH_p; 
40114       
40115 #line 1426 "frontend/machine/pentium/decoder.m"
40116       
40117 
40118             stmts = instantiate(pc,  "ANDrmow", DIS_REG16, DIS_EADDR16);
40119 
40120       
40121 
40122       
40123       
40124       
40125     } 
40126     goto MATCH_finished_c; 
40127     
40128   MATCH_label_c192: (void)0; /*placeholder for label*/ 
40129     { 
40130       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40131       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40132       nextPC = 7 + MATCH_p; 
40133       
40134 #line 1426 "frontend/machine/pentium/decoder.m"
40135       
40136 
40137             stmts = instantiate(pc,  "ANDrmow", DIS_REG16, DIS_EADDR16);
40138 
40139       
40140 
40141       
40142       
40143       
40144     } 
40145     goto MATCH_finished_c; 
40146     
40147   MATCH_label_c193: (void)0; /*placeholder for label*/ 
40148     { 
40149       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40150       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40151       nextPC = 3 + MATCH_p; 
40152       
40153 #line 1420 "frontend/machine/pentium/decoder.m"
40154       
40155 
40156             stmts = instantiate(pc,  "SUBrmow", DIS_REG16, DIS_EADDR16);
40157 
40158       
40159 
40160       
40161       
40162       
40163     } 
40164     goto MATCH_finished_c; 
40165     
40166   MATCH_label_c194: (void)0; /*placeholder for label*/ 
40167     { 
40168       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40169       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40170       nextPC = 4 + MATCH_p; 
40171       
40172 #line 1420 "frontend/machine/pentium/decoder.m"
40173       
40174 
40175             stmts = instantiate(pc,  "SUBrmow", DIS_REG16, DIS_EADDR16);
40176 
40177       
40178 
40179       
40180       
40181       
40182     } 
40183     goto MATCH_finished_c; 
40184     
40185   MATCH_label_c195: (void)0; /*placeholder for label*/ 
40186     { 
40187       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40188       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40189       nextPC = 8 + MATCH_p; 
40190       
40191 #line 1420 "frontend/machine/pentium/decoder.m"
40192       
40193 
40194             stmts = instantiate(pc,  "SUBrmow", DIS_REG16, DIS_EADDR16);
40195 
40196       
40197 
40198       
40199       
40200       
40201     } 
40202     goto MATCH_finished_c; 
40203     
40204   MATCH_label_c196: (void)0; /*placeholder for label*/ 
40205     { 
40206       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40207       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40208       nextPC = 7 + MATCH_p; 
40209       
40210 #line 1420 "frontend/machine/pentium/decoder.m"
40211       
40212 
40213             stmts = instantiate(pc,  "SUBrmow", DIS_REG16, DIS_EADDR16);
40214 
40215       
40216 
40217       
40218       
40219       
40220     } 
40221     goto MATCH_finished_c; 
40222     
40223   MATCH_label_c197: (void)0; /*placeholder for label*/ 
40224     { 
40225       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40226       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40227       nextPC = 3 + MATCH_p; 
40228       
40229 #line 1486 "frontend/machine/pentium/decoder.m"
40230       
40231 
40232             stmts = instantiate(pc,  "XORmrow", DIS_EADDR16, DIS_REG16);
40233 
40234       
40235 
40236       
40237       
40238       
40239     } 
40240     goto MATCH_finished_c; 
40241     
40242   MATCH_label_c198: (void)0; /*placeholder for label*/ 
40243     { 
40244       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40245       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40246       nextPC = 4 + MATCH_p; 
40247       
40248 #line 1486 "frontend/machine/pentium/decoder.m"
40249       
40250 
40251             stmts = instantiate(pc,  "XORmrow", DIS_EADDR16, DIS_REG16);
40252 
40253       
40254 
40255       
40256       
40257       
40258     } 
40259     goto MATCH_finished_c; 
40260     
40261   MATCH_label_c199: (void)0; /*placeholder for label*/ 
40262     { 
40263       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40264       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40265       nextPC = 8 + MATCH_p; 
40266       
40267 #line 1486 "frontend/machine/pentium/decoder.m"
40268       
40269 
40270             stmts = instantiate(pc,  "XORmrow", DIS_EADDR16, DIS_REG16);
40271 
40272       
40273 
40274       
40275       
40276       
40277     } 
40278     goto MATCH_finished_c; 
40279     
40280   MATCH_label_c200: (void)0; /*placeholder for label*/ 
40281     { 
40282       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40283       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40284       nextPC = 7 + MATCH_p; 
40285       
40286 #line 1486 "frontend/machine/pentium/decoder.m"
40287       
40288 
40289             stmts = instantiate(pc,  "XORmrow", DIS_EADDR16, DIS_REG16);
40290 
40291       
40292 
40293       
40294       
40295       
40296     } 
40297     goto MATCH_finished_c; 
40298     
40299   MATCH_label_c201: (void)0; /*placeholder for label*/ 
40300     { 
40301       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40302       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40303       nextPC = 3 + MATCH_p; 
40304       
40305 #line 1480 "frontend/machine/pentium/decoder.m"
40306       
40307 
40308             stmts = instantiate(pc,  "CMPmrow", DIS_EADDR16, DIS_REG16);
40309 
40310       
40311 
40312       
40313       
40314       
40315     } 
40316     goto MATCH_finished_c; 
40317     
40318   MATCH_label_c202: (void)0; /*placeholder for label*/ 
40319     { 
40320       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40321       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40322       nextPC = 4 + MATCH_p; 
40323       
40324 #line 1480 "frontend/machine/pentium/decoder.m"
40325       
40326 
40327             stmts = instantiate(pc,  "CMPmrow", DIS_EADDR16, DIS_REG16);
40328 
40329       
40330 
40331       
40332       
40333       
40334     } 
40335     goto MATCH_finished_c; 
40336     
40337   MATCH_label_c203: (void)0; /*placeholder for label*/ 
40338     { 
40339       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40340       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40341       nextPC = 8 + MATCH_p; 
40342       
40343 #line 1480 "frontend/machine/pentium/decoder.m"
40344       
40345 
40346             stmts = instantiate(pc,  "CMPmrow", DIS_EADDR16, DIS_REG16);
40347 
40348       
40349 
40350       
40351       
40352       
40353     } 
40354     goto MATCH_finished_c; 
40355     
40356   MATCH_label_c204: (void)0; /*placeholder for label*/ 
40357     { 
40358       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40359       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40360       nextPC = 7 + MATCH_p; 
40361       
40362 #line 1480 "frontend/machine/pentium/decoder.m"
40363       
40364 
40365             stmts = instantiate(pc,  "CMPmrow", DIS_EADDR16, DIS_REG16);
40366 
40367       
40368 
40369       
40370       
40371       
40372     } 
40373     goto MATCH_finished_c; 
40374     
40375   MATCH_label_c205: (void)0; /*placeholder for label*/ 
40376     { 
40377       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40378       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40379       nextPC = 3 + MATCH_p; 
40380       
40381 #line 1414 "frontend/machine/pentium/decoder.m"
40382       
40383 
40384             stmts = instantiate(pc,  "XORrmow", DIS_REG16, DIS_EADDR16);
40385 
40386       
40387 
40388       
40389       
40390       
40391     } 
40392     goto MATCH_finished_c; 
40393     
40394   MATCH_label_c206: (void)0; /*placeholder for label*/ 
40395     { 
40396       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40397       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40398       nextPC = 4 + MATCH_p; 
40399       
40400 #line 1414 "frontend/machine/pentium/decoder.m"
40401       
40402 
40403             stmts = instantiate(pc,  "XORrmow", DIS_REG16, DIS_EADDR16);
40404 
40405       
40406 
40407       
40408       
40409       
40410     } 
40411     goto MATCH_finished_c; 
40412     
40413   MATCH_label_c207: (void)0; /*placeholder for label*/ 
40414     { 
40415       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40416       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40417       nextPC = 8 + MATCH_p; 
40418       
40419 #line 1414 "frontend/machine/pentium/decoder.m"
40420       
40421 
40422             stmts = instantiate(pc,  "XORrmow", DIS_REG16, DIS_EADDR16);
40423 
40424       
40425 
40426       
40427       
40428       
40429     } 
40430     goto MATCH_finished_c; 
40431     
40432   MATCH_label_c208: (void)0; /*placeholder for label*/ 
40433     { 
40434       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40435       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40436       nextPC = 7 + MATCH_p; 
40437       
40438 #line 1414 "frontend/machine/pentium/decoder.m"
40439       
40440 
40441             stmts = instantiate(pc,  "XORrmow", DIS_REG16, DIS_EADDR16);
40442 
40443       
40444 
40445       
40446       
40447       
40448     } 
40449     goto MATCH_finished_c; 
40450     
40451   MATCH_label_c209: (void)0; /*placeholder for label*/ 
40452     { 
40453       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40454       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40455       nextPC = 3 + MATCH_p; 
40456       
40457 #line 1408 "frontend/machine/pentium/decoder.m"
40458       
40459 
40460             stmts = instantiate(pc,  "CMPrmow", DIS_REG16, DIS_EADDR16);
40461 
40462       
40463 
40464       
40465       
40466       
40467     } 
40468     goto MATCH_finished_c; 
40469     
40470   MATCH_label_c210: (void)0; /*placeholder for label*/ 
40471     { 
40472       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40473       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40474       nextPC = 4 + MATCH_p; 
40475       
40476 #line 1408 "frontend/machine/pentium/decoder.m"
40477       
40478 
40479             stmts = instantiate(pc,  "CMPrmow", DIS_REG16, DIS_EADDR16);
40480 
40481       
40482 
40483       
40484       
40485       
40486     } 
40487     goto MATCH_finished_c; 
40488     
40489   MATCH_label_c211: (void)0; /*placeholder for label*/ 
40490     { 
40491       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40492       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40493       nextPC = 8 + MATCH_p; 
40494       
40495 #line 1408 "frontend/machine/pentium/decoder.m"
40496       
40497 
40498             stmts = instantiate(pc,  "CMPrmow", DIS_REG16, DIS_EADDR16);
40499 
40500       
40501 
40502       
40503       
40504       
40505     } 
40506     goto MATCH_finished_c; 
40507     
40508   MATCH_label_c212: (void)0; /*placeholder for label*/ 
40509     { 
40510       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40511       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40512       nextPC = 7 + MATCH_p; 
40513       
40514 #line 1408 "frontend/machine/pentium/decoder.m"
40515       
40516 
40517             stmts = instantiate(pc,  "CMPrmow", DIS_REG16, DIS_EADDR16);
40518 
40519       
40520 
40521       
40522       
40523       
40524     } 
40525     goto MATCH_finished_c; 
40526     
40527   MATCH_label_c213: (void)0; /*placeholder for label*/ 
40528     { 
40529       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40530       int /* [~32768..32767] */ i16 = 
40531         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
40532       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40533       nextPC = 5 + MATCH_p; 
40534       
40535 #line 1157 "frontend/machine/pentium/decoder.m"
40536       
40537 
40538             stmts = instantiate(pc,  "IMUL.Ivw", DIS_REG16, DIS_EADDR16, DIS_I16);
40539 
40540       
40541 
40542       
40543       
40544       
40545     } 
40546     goto MATCH_finished_c; 
40547     
40548   MATCH_label_c214: (void)0; /*placeholder for label*/ 
40549     { 
40550       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40551       int /* [~32768..32767] */ i16 = 
40552         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
40553       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40554       nextPC = 6 + MATCH_p; 
40555       
40556 #line 1157 "frontend/machine/pentium/decoder.m"
40557       
40558 
40559             stmts = instantiate(pc,  "IMUL.Ivw", DIS_REG16, DIS_EADDR16, DIS_I16);
40560 
40561       
40562 
40563       
40564       
40565       
40566     } 
40567     goto MATCH_finished_c; 
40568     
40569   MATCH_label_c215: (void)0; /*placeholder for label*/ 
40570     { 
40571       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40572       int /* [~32768..32767] */ i16 = 
40573         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
40574       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40575       nextPC = 10 + MATCH_p; 
40576       
40577 #line 1157 "frontend/machine/pentium/decoder.m"
40578       
40579 
40580             stmts = instantiate(pc,  "IMUL.Ivw", DIS_REG16, DIS_EADDR16, DIS_I16);
40581 
40582       
40583 
40584       
40585       
40586       
40587     } 
40588     goto MATCH_finished_c; 
40589     
40590   MATCH_label_c216: (void)0; /*placeholder for label*/ 
40591     { 
40592       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40593       int /* [~32768..32767] */ i16 = 
40594         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
40595       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40596       nextPC = 9 + MATCH_p; 
40597       
40598 #line 1157 "frontend/machine/pentium/decoder.m"
40599       
40600 
40601             stmts = instantiate(pc,  "IMUL.Ivw", DIS_REG16, DIS_EADDR16, DIS_I16);
40602 
40603       
40604 
40605       
40606       
40607       
40608     } 
40609     goto MATCH_finished_c; 
40610     
40611   MATCH_label_c217: (void)0; /*placeholder for label*/ 
40612     { 
40613       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40614       int /* [~128..127] */ i8 = 
40615         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
40616       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40617       nextPC = 4 + MATCH_p; 
40618       
40619 #line 1163 "frontend/machine/pentium/decoder.m"
40620       
40621 
40622             stmts = instantiate(pc,  "IMUL.Ibow", DIS_REG16, DIS_EADDR16, DIS_I8);
40623 
40624       
40625 
40626       
40627       
40628       
40629     } 
40630     goto MATCH_finished_c; 
40631     
40632   MATCH_label_c218: (void)0; /*placeholder for label*/ 
40633     { 
40634       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40635       int /* [~128..127] */ i8 = 
40636         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
40637       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40638       nextPC = 5 + MATCH_p; 
40639       
40640 #line 1163 "frontend/machine/pentium/decoder.m"
40641       
40642 
40643             stmts = instantiate(pc,  "IMUL.Ibow", DIS_REG16, DIS_EADDR16, DIS_I8);
40644 
40645       
40646 
40647       
40648       
40649       
40650     } 
40651     goto MATCH_finished_c; 
40652     
40653   MATCH_label_c219: (void)0; /*placeholder for label*/ 
40654     { 
40655       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40656       int /* [~128..127] */ i8 = 
40657         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
40658       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40659       nextPC = 9 + MATCH_p; 
40660       
40661 #line 1163 "frontend/machine/pentium/decoder.m"
40662       
40663 
40664             stmts = instantiate(pc,  "IMUL.Ibow", DIS_REG16, DIS_EADDR16, DIS_I8);
40665 
40666       
40667 
40668       
40669       
40670       
40671     } 
40672     goto MATCH_finished_c; 
40673     
40674   MATCH_label_c220: (void)0; /*placeholder for label*/ 
40675     { 
40676       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40677       int /* [~128..127] */ i8 = 
40678         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
40679       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
40680       nextPC = 8 + MATCH_p; 
40681       
40682 #line 1163 "frontend/machine/pentium/decoder.m"
40683       
40684 
40685             stmts = instantiate(pc,  "IMUL.Ibow", DIS_REG16, DIS_EADDR16, DIS_I8);
40686 
40687       
40688 
40689       
40690       
40691       
40692     } 
40693     goto MATCH_finished_c; 
40694     
40695   MATCH_label_c221: (void)0; /*placeholder for label*/ 
40696     { 
40697       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40698       int /* [~32768..32767] */ i16 = 
40699         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
40700       nextPC = 5 + MATCH_p; 
40701       
40702 #line 1645 "frontend/machine/pentium/decoder.m"
40703       
40704 
40705             stmts = instantiate(pc,  "ADDiw", DIS_EADDR16, DIS_I16);
40706 
40707       
40708 
40709       
40710       
40711       
40712     } 
40713     goto MATCH_finished_c; 
40714     
40715   MATCH_label_c222: (void)0; /*placeholder for label*/ 
40716     { 
40717       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40718       int /* [~32768..32767] */ i16 = 
40719         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
40720       nextPC = 6 + MATCH_p; 
40721       
40722 #line 1645 "frontend/machine/pentium/decoder.m"
40723       
40724 
40725             stmts = instantiate(pc,  "ADDiw", DIS_EADDR16, DIS_I16);
40726 
40727       
40728 
40729       
40730       
40731       
40732     } 
40733     goto MATCH_finished_c; 
40734     
40735   MATCH_label_c223: (void)0; /*placeholder for label*/ 
40736     { 
40737       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40738       int /* [~32768..32767] */ i16 = 
40739         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
40740       nextPC = 10 + MATCH_p; 
40741       
40742 #line 1645 "frontend/machine/pentium/decoder.m"
40743       
40744 
40745             stmts = instantiate(pc,  "ADDiw", DIS_EADDR16, DIS_I16);
40746 
40747       
40748 
40749       
40750       
40751       
40752     } 
40753     goto MATCH_finished_c; 
40754     
40755   MATCH_label_c224: (void)0; /*placeholder for label*/ 
40756     { 
40757       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40758       int /* [~32768..32767] */ i16 = 
40759         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
40760       nextPC = 9 + MATCH_p; 
40761       
40762 #line 1645 "frontend/machine/pentium/decoder.m"
40763       
40764 
40765             stmts = instantiate(pc,  "ADDiw", DIS_EADDR16, DIS_I16);
40766 
40767       
40768 
40769       
40770       
40771       
40772     } 
40773     goto MATCH_finished_c; 
40774     
40775   MATCH_label_c225: (void)0; /*placeholder for label*/ 
40776     { 
40777       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40778       int /* [~32768..32767] */ i16 = 
40779         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
40780       nextPC = 5 + MATCH_p; 
40781       
40782 #line 1642 "frontend/machine/pentium/decoder.m"
40783       
40784 
40785             stmts = instantiate(pc,  "ORiw", DIS_EADDR16, DIS_I16);
40786 
40787       
40788 
40789       
40790       
40791       
40792     } 
40793     goto MATCH_finished_c; 
40794     
40795   MATCH_label_c226: (void)0; /*placeholder for label*/ 
40796     { 
40797       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40798       int /* [~32768..32767] */ i16 = 
40799         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
40800       nextPC = 6 + MATCH_p; 
40801       
40802 #line 1642 "frontend/machine/pentium/decoder.m"
40803       
40804 
40805             stmts = instantiate(pc,  "ORiw", DIS_EADDR16, DIS_I16);
40806 
40807       
40808 
40809       
40810       
40811       
40812     } 
40813     goto MATCH_finished_c; 
40814     
40815   MATCH_label_c227: (void)0; /*placeholder for label*/ 
40816     { 
40817       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40818       int /* [~32768..32767] */ i16 = 
40819         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
40820       nextPC = 10 + MATCH_p; 
40821       
40822 #line 1642 "frontend/machine/pentium/decoder.m"
40823       
40824 
40825             stmts = instantiate(pc,  "ORiw", DIS_EADDR16, DIS_I16);
40826 
40827       
40828 
40829       
40830       
40831       
40832     } 
40833     goto MATCH_finished_c; 
40834     
40835   MATCH_label_c228: (void)0; /*placeholder for label*/ 
40836     { 
40837       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40838       int /* [~32768..32767] */ i16 = 
40839         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
40840       nextPC = 9 + MATCH_p; 
40841       
40842 #line 1642 "frontend/machine/pentium/decoder.m"
40843       
40844 
40845             stmts = instantiate(pc,  "ORiw", DIS_EADDR16, DIS_I16);
40846 
40847       
40848 
40849       
40850       
40851       
40852     } 
40853     goto MATCH_finished_c; 
40854     
40855   MATCH_label_c229: (void)0; /*placeholder for label*/ 
40856     { 
40857       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40858       int /* [~32768..32767] */ i16 = 
40859         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
40860       nextPC = 5 + MATCH_p; 
40861       
40862 #line 1639 "frontend/machine/pentium/decoder.m"
40863       
40864 
40865             stmts = instantiate(pc,  "ADCiw", DIS_EADDR16, DIS_I16);
40866 
40867       
40868 
40869       
40870       
40871       
40872     } 
40873     goto MATCH_finished_c; 
40874     
40875   MATCH_label_c230: (void)0; /*placeholder for label*/ 
40876     { 
40877       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40878       int /* [~32768..32767] */ i16 = 
40879         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
40880       nextPC = 6 + MATCH_p; 
40881       
40882 #line 1639 "frontend/machine/pentium/decoder.m"
40883       
40884 
40885             stmts = instantiate(pc,  "ADCiw", DIS_EADDR16, DIS_I16);
40886 
40887       
40888 
40889       
40890       
40891       
40892     } 
40893     goto MATCH_finished_c; 
40894     
40895   MATCH_label_c231: (void)0; /*placeholder for label*/ 
40896     { 
40897       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40898       int /* [~32768..32767] */ i16 = 
40899         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
40900       nextPC = 10 + MATCH_p; 
40901       
40902 #line 1639 "frontend/machine/pentium/decoder.m"
40903       
40904 
40905             stmts = instantiate(pc,  "ADCiw", DIS_EADDR16, DIS_I16);
40906 
40907       
40908 
40909       
40910       
40911       
40912     } 
40913     goto MATCH_finished_c; 
40914     
40915   MATCH_label_c232: (void)0; /*placeholder for label*/ 
40916     { 
40917       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40918       int /* [~32768..32767] */ i16 = 
40919         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
40920       nextPC = 9 + MATCH_p; 
40921       
40922 #line 1639 "frontend/machine/pentium/decoder.m"
40923       
40924 
40925             stmts = instantiate(pc,  "ADCiw", DIS_EADDR16, DIS_I16);
40926 
40927       
40928 
40929       
40930       
40931       
40932     } 
40933     goto MATCH_finished_c; 
40934     
40935   MATCH_label_c233: (void)0; /*placeholder for label*/ 
40936     { 
40937       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40938       int /* [~32768..32767] */ i16 = 
40939         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
40940       nextPC = 5 + MATCH_p; 
40941       
40942 #line 1636 "frontend/machine/pentium/decoder.m"
40943       
40944 
40945             stmts = instantiate(pc,  "SBBiw", DIS_EADDR16, DIS_I16);
40946 
40947       
40948 
40949       
40950       
40951       
40952     } 
40953     goto MATCH_finished_c; 
40954     
40955   MATCH_label_c234: (void)0; /*placeholder for label*/ 
40956     { 
40957       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40958       int /* [~32768..32767] */ i16 = 
40959         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
40960       nextPC = 6 + MATCH_p; 
40961       
40962 #line 1636 "frontend/machine/pentium/decoder.m"
40963       
40964 
40965             stmts = instantiate(pc,  "SBBiw", DIS_EADDR16, DIS_I16);
40966 
40967       
40968 
40969       
40970       
40971       
40972     } 
40973     goto MATCH_finished_c; 
40974     
40975   MATCH_label_c235: (void)0; /*placeholder for label*/ 
40976     { 
40977       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40978       int /* [~32768..32767] */ i16 = 
40979         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
40980       nextPC = 10 + MATCH_p; 
40981       
40982 #line 1636 "frontend/machine/pentium/decoder.m"
40983       
40984 
40985             stmts = instantiate(pc,  "SBBiw", DIS_EADDR16, DIS_I16);
40986 
40987       
40988 
40989       
40990       
40991       
40992     } 
40993     goto MATCH_finished_c; 
40994     
40995   MATCH_label_c236: (void)0; /*placeholder for label*/ 
40996     { 
40997       unsigned Eaddr = 2 + addressToPC(MATCH_p);
40998       int /* [~32768..32767] */ i16 = 
40999         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
41000       nextPC = 9 + MATCH_p; 
41001       
41002 #line 1636 "frontend/machine/pentium/decoder.m"
41003       
41004 
41005             stmts = instantiate(pc,  "SBBiw", DIS_EADDR16, DIS_I16);
41006 
41007       
41008 
41009       
41010       
41011       
41012     } 
41013     goto MATCH_finished_c; 
41014     
41015   MATCH_label_c237: (void)0; /*placeholder for label*/ 
41016     { 
41017       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41018       int /* [~32768..32767] */ i16 = 
41019         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
41020       nextPC = 5 + MATCH_p; 
41021       
41022 #line 1633 "frontend/machine/pentium/decoder.m"
41023       
41024 
41025             stmts = instantiate(pc,  "ANDiw", DIS_EADDR16, DIS_I16);
41026 
41027       
41028 
41029       
41030       
41031       
41032     } 
41033     goto MATCH_finished_c; 
41034     
41035   MATCH_label_c238: (void)0; /*placeholder for label*/ 
41036     { 
41037       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41038       int /* [~32768..32767] */ i16 = 
41039         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
41040       nextPC = 6 + MATCH_p; 
41041       
41042 #line 1633 "frontend/machine/pentium/decoder.m"
41043       
41044 
41045             stmts = instantiate(pc,  "ANDiw", DIS_EADDR16, DIS_I16);
41046 
41047       
41048 
41049       
41050       
41051       
41052     } 
41053     goto MATCH_finished_c; 
41054     
41055   MATCH_label_c239: (void)0; /*placeholder for label*/ 
41056     { 
41057       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41058       int /* [~32768..32767] */ i16 = 
41059         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
41060       nextPC = 10 + MATCH_p; 
41061       
41062 #line 1633 "frontend/machine/pentium/decoder.m"
41063       
41064 
41065             stmts = instantiate(pc,  "ANDiw", DIS_EADDR16, DIS_I16);
41066 
41067       
41068 
41069       
41070       
41071       
41072     } 
41073     goto MATCH_finished_c; 
41074     
41075   MATCH_label_c240: (void)0; /*placeholder for label*/ 
41076     { 
41077       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41078       int /* [~32768..32767] */ i16 = 
41079         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
41080       nextPC = 9 + MATCH_p; 
41081       
41082 #line 1633 "frontend/machine/pentium/decoder.m"
41083       
41084 
41085             stmts = instantiate(pc,  "ANDiw", DIS_EADDR16, DIS_I16);
41086 
41087       
41088 
41089       
41090       
41091       
41092     } 
41093     goto MATCH_finished_c; 
41094     
41095   MATCH_label_c241: (void)0; /*placeholder for label*/ 
41096     { 
41097       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41098       int /* [~32768..32767] */ i16 = 
41099         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
41100       nextPC = 5 + MATCH_p; 
41101       
41102 #line 1630 "frontend/machine/pentium/decoder.m"
41103       
41104 
41105             stmts = instantiate(pc,  "SUBiw", DIS_EADDR16, DIS_I16);
41106 
41107       
41108 
41109       
41110       
41111       
41112     } 
41113     goto MATCH_finished_c; 
41114     
41115   MATCH_label_c242: (void)0; /*placeholder for label*/ 
41116     { 
41117       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41118       int /* [~32768..32767] */ i16 = 
41119         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
41120       nextPC = 6 + MATCH_p; 
41121       
41122 #line 1630 "frontend/machine/pentium/decoder.m"
41123       
41124 
41125             stmts = instantiate(pc,  "SUBiw", DIS_EADDR16, DIS_I16);
41126 
41127       
41128 
41129       
41130       
41131       
41132     } 
41133     goto MATCH_finished_c; 
41134     
41135   MATCH_label_c243: (void)0; /*placeholder for label*/ 
41136     { 
41137       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41138       int /* [~32768..32767] */ i16 = 
41139         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
41140       nextPC = 10 + MATCH_p; 
41141       
41142 #line 1630 "frontend/machine/pentium/decoder.m"
41143       
41144 
41145             stmts = instantiate(pc,  "SUBiw", DIS_EADDR16, DIS_I16);
41146 
41147       
41148 
41149       
41150       
41151       
41152     } 
41153     goto MATCH_finished_c; 
41154     
41155   MATCH_label_c244: (void)0; /*placeholder for label*/ 
41156     { 
41157       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41158       int /* [~32768..32767] */ i16 = 
41159         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
41160       nextPC = 9 + MATCH_p; 
41161       
41162 #line 1630 "frontend/machine/pentium/decoder.m"
41163       
41164 
41165             stmts = instantiate(pc,  "SUBiw", DIS_EADDR16, DIS_I16);
41166 
41167       
41168 
41169       
41170       
41171       
41172     } 
41173     goto MATCH_finished_c; 
41174     
41175   MATCH_label_c245: (void)0; /*placeholder for label*/ 
41176     { 
41177       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41178       int /* [~32768..32767] */ i16 = 
41179         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
41180       nextPC = 5 + MATCH_p; 
41181       
41182 #line 1627 "frontend/machine/pentium/decoder.m"
41183       
41184 
41185             stmts = instantiate(pc,  "XORiw", DIS_EADDR16, DIS_I16);
41186 
41187       
41188 
41189       
41190       
41191       
41192     } 
41193     goto MATCH_finished_c; 
41194     
41195   MATCH_label_c246: (void)0; /*placeholder for label*/ 
41196     { 
41197       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41198       int /* [~32768..32767] */ i16 = 
41199         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
41200       nextPC = 6 + MATCH_p; 
41201       
41202 #line 1627 "frontend/machine/pentium/decoder.m"
41203       
41204 
41205             stmts = instantiate(pc,  "XORiw", DIS_EADDR16, DIS_I16);
41206 
41207       
41208 
41209       
41210       
41211       
41212     } 
41213     goto MATCH_finished_c; 
41214     
41215   MATCH_label_c247: (void)0; /*placeholder for label*/ 
41216     { 
41217       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41218       int /* [~32768..32767] */ i16 = 
41219         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
41220       nextPC = 10 + MATCH_p; 
41221       
41222 #line 1627 "frontend/machine/pentium/decoder.m"
41223       
41224 
41225             stmts = instantiate(pc,  "XORiw", DIS_EADDR16, DIS_I16);
41226 
41227       
41228 
41229       
41230       
41231       
41232     } 
41233     goto MATCH_finished_c; 
41234     
41235   MATCH_label_c248: (void)0; /*placeholder for label*/ 
41236     { 
41237       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41238       int /* [~32768..32767] */ i16 = 
41239         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
41240       nextPC = 9 + MATCH_p; 
41241       
41242 #line 1627 "frontend/machine/pentium/decoder.m"
41243       
41244 
41245             stmts = instantiate(pc,  "XORiw", DIS_EADDR16, DIS_I16);
41246 
41247       
41248 
41249       
41250       
41251       
41252     } 
41253     goto MATCH_finished_c; 
41254     
41255   MATCH_label_c249: (void)0; /*placeholder for label*/ 
41256     { 
41257       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41258       int /* [~32768..32767] */ i16 = 
41259         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
41260       nextPC = 5 + MATCH_p; 
41261       
41262 #line 1624 "frontend/machine/pentium/decoder.m"
41263       
41264 
41265             stmts = instantiate(pc,  "CMPiw", DIS_EADDR16, DIS_I16);
41266 
41267       
41268 
41269       
41270       
41271       
41272     } 
41273     goto MATCH_finished_c; 
41274     
41275   MATCH_label_c250: (void)0; /*placeholder for label*/ 
41276     { 
41277       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41278       int /* [~32768..32767] */ i16 = 
41279         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
41280       nextPC = 6 + MATCH_p; 
41281       
41282 #line 1624 "frontend/machine/pentium/decoder.m"
41283       
41284 
41285             stmts = instantiate(pc,  "CMPiw", DIS_EADDR16, DIS_I16);
41286 
41287       
41288 
41289       
41290       
41291       
41292     } 
41293     goto MATCH_finished_c; 
41294     
41295   MATCH_label_c251: (void)0; /*placeholder for label*/ 
41296     { 
41297       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41298       int /* [~32768..32767] */ i16 = 
41299         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
41300       nextPC = 10 + MATCH_p; 
41301       
41302 #line 1624 "frontend/machine/pentium/decoder.m"
41303       
41304 
41305             stmts = instantiate(pc,  "CMPiw", DIS_EADDR16, DIS_I16);
41306 
41307       
41308 
41309       
41310       
41311       
41312     } 
41313     goto MATCH_finished_c; 
41314     
41315   MATCH_label_c252: (void)0; /*placeholder for label*/ 
41316     { 
41317       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41318       int /* [~32768..32767] */ i16 = 
41319         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
41320       nextPC = 9 + MATCH_p; 
41321       
41322 #line 1624 "frontend/machine/pentium/decoder.m"
41323       
41324 
41325             stmts = instantiate(pc,  "CMPiw", DIS_EADDR16, DIS_I16);
41326 
41327       
41328 
41329       
41330       
41331       
41332     } 
41333     goto MATCH_finished_c; 
41334     
41335   MATCH_label_c253: (void)0; /*placeholder for label*/ 
41336     { 
41337       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41338       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41339       nextPC = 3 + MATCH_p; 
41340       
41341 #line 1034 "frontend/machine/pentium/decoder.m"
41342       
41343 
41344             stmts = instantiate(pc,  "MOVmrow", DIS_EADDR16, DIS_REG16);
41345 
41346       
41347 
41348       
41349       
41350       
41351     } 
41352     goto MATCH_finished_c; 
41353     
41354   MATCH_label_c254: (void)0; /*placeholder for label*/ 
41355     { 
41356       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41357       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41358       nextPC = 4 + MATCH_p; 
41359       
41360 #line 1034 "frontend/machine/pentium/decoder.m"
41361       
41362 
41363             stmts = instantiate(pc,  "MOVmrow", DIS_EADDR16, DIS_REG16);
41364 
41365       
41366 
41367       
41368       
41369       
41370     } 
41371     goto MATCH_finished_c; 
41372     
41373   MATCH_label_c255: (void)0; /*placeholder for label*/ 
41374     { 
41375       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41376       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41377       nextPC = 8 + MATCH_p; 
41378       
41379 #line 1034 "frontend/machine/pentium/decoder.m"
41380       
41381 
41382             stmts = instantiate(pc,  "MOVmrow", DIS_EADDR16, DIS_REG16);
41383 
41384       
41385 
41386       
41387       
41388       
41389     } 
41390     goto MATCH_finished_c; 
41391     
41392   MATCH_label_c256: (void)0; /*placeholder for label*/ 
41393     { 
41394       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41395       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41396       nextPC = 7 + MATCH_p; 
41397       
41398 #line 1034 "frontend/machine/pentium/decoder.m"
41399       
41400 
41401             stmts = instantiate(pc,  "MOVmrow", DIS_EADDR16, DIS_REG16);
41402 
41403       
41404 
41405       
41406       
41407       
41408     } 
41409     goto MATCH_finished_c; 
41410     
41411   MATCH_label_c257: (void)0; /*placeholder for label*/ 
41412     { 
41413       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41414       int /* [~128..127] */ i8 = 
41415         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
41416       nextPC = 4 + MATCH_p; 
41417       
41418 #line 1597 "frontend/machine/pentium/decoder.m"
41419       
41420 
41421             stmts = instantiate(pc,  "ADDiowb", DIS_EADDR16, DIS_I8);
41422 
41423       
41424 
41425       
41426       
41427       
41428     } 
41429     goto MATCH_finished_c; 
41430     
41431   MATCH_label_c258: (void)0; /*placeholder for label*/ 
41432     { 
41433       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41434       int /* [~128..127] */ i8 = 
41435         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
41436       nextPC = 5 + MATCH_p; 
41437       
41438 #line 1597 "frontend/machine/pentium/decoder.m"
41439       
41440 
41441             stmts = instantiate(pc,  "ADDiowb", DIS_EADDR16, DIS_I8);
41442 
41443       
41444 
41445       
41446       
41447       
41448     } 
41449     goto MATCH_finished_c; 
41450     
41451   MATCH_label_c259: (void)0; /*placeholder for label*/ 
41452     { 
41453       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41454       int /* [~128..127] */ i8 = 
41455         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
41456       nextPC = 9 + MATCH_p; 
41457       
41458 #line 1597 "frontend/machine/pentium/decoder.m"
41459       
41460 
41461             stmts = instantiate(pc,  "ADDiowb", DIS_EADDR16, DIS_I8);
41462 
41463       
41464 
41465       
41466       
41467       
41468     } 
41469     goto MATCH_finished_c; 
41470     
41471   MATCH_label_c260: (void)0; /*placeholder for label*/ 
41472     { 
41473       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41474       int /* [~128..127] */ i8 = 
41475         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
41476       nextPC = 8 + MATCH_p; 
41477       
41478 #line 1597 "frontend/machine/pentium/decoder.m"
41479       
41480 
41481             stmts = instantiate(pc,  "ADDiowb", DIS_EADDR16, DIS_I8);
41482 
41483       
41484 
41485       
41486       
41487       
41488     } 
41489     goto MATCH_finished_c; 
41490     
41491   MATCH_label_c261: (void)0; /*placeholder for label*/ 
41492     { 
41493       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41494       int /* [~128..127] */ i8 = 
41495         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
41496       nextPC = 4 + MATCH_p; 
41497       
41498 #line 1591 "frontend/machine/pentium/decoder.m"
41499       
41500 
41501             stmts = instantiate(pc,  "ORiowb", DIS_EADDR16, DIS_I8);
41502 
41503       
41504 
41505       
41506       
41507       
41508     } 
41509     goto MATCH_finished_c; 
41510     
41511   MATCH_label_c262: (void)0; /*placeholder for label*/ 
41512     { 
41513       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41514       int /* [~128..127] */ i8 = 
41515         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
41516       nextPC = 5 + MATCH_p; 
41517       
41518 #line 1591 "frontend/machine/pentium/decoder.m"
41519       
41520 
41521             stmts = instantiate(pc,  "ORiowb", DIS_EADDR16, DIS_I8);
41522 
41523       
41524 
41525       
41526       
41527       
41528     } 
41529     goto MATCH_finished_c; 
41530     
41531   MATCH_label_c263: (void)0; /*placeholder for label*/ 
41532     { 
41533       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41534       int /* [~128..127] */ i8 = 
41535         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
41536       nextPC = 9 + MATCH_p; 
41537       
41538 #line 1591 "frontend/machine/pentium/decoder.m"
41539       
41540 
41541             stmts = instantiate(pc,  "ORiowb", DIS_EADDR16, DIS_I8);
41542 
41543       
41544 
41545       
41546       
41547       
41548     } 
41549     goto MATCH_finished_c; 
41550     
41551   MATCH_label_c264: (void)0; /*placeholder for label*/ 
41552     { 
41553       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41554       int /* [~128..127] */ i8 = 
41555         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
41556       nextPC = 8 + MATCH_p; 
41557       
41558 #line 1591 "frontend/machine/pentium/decoder.m"
41559       
41560 
41561             stmts = instantiate(pc,  "ORiowb", DIS_EADDR16, DIS_I8);
41562 
41563       
41564 
41565       
41566       
41567       
41568     } 
41569     goto MATCH_finished_c; 
41570     
41571   MATCH_label_c265: (void)0; /*placeholder for label*/ 
41572     { 
41573       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41574       int /* [~128..127] */ i8 = 
41575         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
41576       nextPC = 4 + MATCH_p; 
41577       
41578 #line 1585 "frontend/machine/pentium/decoder.m"
41579       
41580 
41581             stmts = instantiate(pc,  "ADCiowb", DIS_EADDR16, DIS_I8);
41582 
41583       
41584 
41585       
41586       
41587       
41588     } 
41589     goto MATCH_finished_c; 
41590     
41591   MATCH_label_c266: (void)0; /*placeholder for label*/ 
41592     { 
41593       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41594       int /* [~128..127] */ i8 = 
41595         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
41596       nextPC = 5 + MATCH_p; 
41597       
41598 #line 1585 "frontend/machine/pentium/decoder.m"
41599       
41600 
41601             stmts = instantiate(pc,  "ADCiowb", DIS_EADDR16, DIS_I8);
41602 
41603       
41604 
41605       
41606       
41607       
41608     } 
41609     goto MATCH_finished_c; 
41610     
41611   MATCH_label_c267: (void)0; /*placeholder for label*/ 
41612     { 
41613       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41614       int /* [~128..127] */ i8 = 
41615         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
41616       nextPC = 9 + MATCH_p; 
41617       
41618 #line 1585 "frontend/machine/pentium/decoder.m"
41619       
41620 
41621             stmts = instantiate(pc,  "ADCiowb", DIS_EADDR16, DIS_I8);
41622 
41623       
41624 
41625       
41626       
41627       
41628     } 
41629     goto MATCH_finished_c; 
41630     
41631   MATCH_label_c268: (void)0; /*placeholder for label*/ 
41632     { 
41633       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41634       int /* [~128..127] */ i8 = 
41635         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
41636       nextPC = 8 + MATCH_p; 
41637       
41638 #line 1585 "frontend/machine/pentium/decoder.m"
41639       
41640 
41641             stmts = instantiate(pc,  "ADCiowb", DIS_EADDR16, DIS_I8);
41642 
41643       
41644 
41645       
41646       
41647       
41648     } 
41649     goto MATCH_finished_c; 
41650     
41651   MATCH_label_c269: (void)0; /*placeholder for label*/ 
41652     { 
41653       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41654       int /* [~128..127] */ i8 = 
41655         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
41656       nextPC = 4 + MATCH_p; 
41657       
41658 #line 1579 "frontend/machine/pentium/decoder.m"
41659       
41660 
41661             stmts = instantiate(pc,  "SBBiowb", DIS_EADDR16, DIS_I8);
41662 
41663       
41664 
41665       
41666       
41667       
41668     } 
41669     goto MATCH_finished_c; 
41670     
41671   MATCH_label_c270: (void)0; /*placeholder for label*/ 
41672     { 
41673       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41674       int /* [~128..127] */ i8 = 
41675         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
41676       nextPC = 5 + MATCH_p; 
41677       
41678 #line 1579 "frontend/machine/pentium/decoder.m"
41679       
41680 
41681             stmts = instantiate(pc,  "SBBiowb", DIS_EADDR16, DIS_I8);
41682 
41683       
41684 
41685       
41686       
41687       
41688     } 
41689     goto MATCH_finished_c; 
41690     
41691   MATCH_label_c271: (void)0; /*placeholder for label*/ 
41692     { 
41693       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41694       int /* [~128..127] */ i8 = 
41695         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
41696       nextPC = 9 + MATCH_p; 
41697       
41698 #line 1579 "frontend/machine/pentium/decoder.m"
41699       
41700 
41701             stmts = instantiate(pc,  "SBBiowb", DIS_EADDR16, DIS_I8);
41702 
41703       
41704 
41705       
41706       
41707       
41708     } 
41709     goto MATCH_finished_c; 
41710     
41711   MATCH_label_c272: (void)0; /*placeholder for label*/ 
41712     { 
41713       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41714       int /* [~128..127] */ i8 = 
41715         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
41716       nextPC = 8 + MATCH_p; 
41717       
41718 #line 1579 "frontend/machine/pentium/decoder.m"
41719       
41720 
41721             stmts = instantiate(pc,  "SBBiowb", DIS_EADDR16, DIS_I8);
41722 
41723       
41724 
41725       
41726       
41727       
41728     } 
41729     goto MATCH_finished_c; 
41730     
41731   MATCH_label_c273: (void)0; /*placeholder for label*/ 
41732     { 
41733       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41734       int /* [~128..127] */ i8 = 
41735         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
41736       nextPC = 4 + MATCH_p; 
41737       
41738 #line 1573 "frontend/machine/pentium/decoder.m"
41739       
41740 
41741             stmts = instantiate(pc,  "ANDiowb", DIS_EADDR16, DIS_I8);
41742 
41743       
41744 
41745       
41746       
41747       
41748     } 
41749     goto MATCH_finished_c; 
41750     
41751   MATCH_label_c274: (void)0; /*placeholder for label*/ 
41752     { 
41753       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41754       int /* [~128..127] */ i8 = 
41755         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
41756       nextPC = 5 + MATCH_p; 
41757       
41758 #line 1573 "frontend/machine/pentium/decoder.m"
41759       
41760 
41761             stmts = instantiate(pc,  "ANDiowb", DIS_EADDR16, DIS_I8);
41762 
41763       
41764 
41765       
41766       
41767       
41768     } 
41769     goto MATCH_finished_c; 
41770     
41771   MATCH_label_c275: (void)0; /*placeholder for label*/ 
41772     { 
41773       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41774       int /* [~128..127] */ i8 = 
41775         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
41776       nextPC = 9 + MATCH_p; 
41777       
41778 #line 1573 "frontend/machine/pentium/decoder.m"
41779       
41780 
41781             stmts = instantiate(pc,  "ANDiowb", DIS_EADDR16, DIS_I8);
41782 
41783       
41784 
41785       
41786       
41787       
41788     } 
41789     goto MATCH_finished_c; 
41790     
41791   MATCH_label_c276: (void)0; /*placeholder for label*/ 
41792     { 
41793       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41794       int /* [~128..127] */ i8 = 
41795         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
41796       nextPC = 8 + MATCH_p; 
41797       
41798 #line 1573 "frontend/machine/pentium/decoder.m"
41799       
41800 
41801             stmts = instantiate(pc,  "ANDiowb", DIS_EADDR16, DIS_I8);
41802 
41803       
41804 
41805       
41806       
41807       
41808     } 
41809     goto MATCH_finished_c; 
41810     
41811   MATCH_label_c277: (void)0; /*placeholder for label*/ 
41812     { 
41813       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41814       int /* [~128..127] */ i8 = 
41815         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
41816       nextPC = 4 + MATCH_p; 
41817       
41818 #line 1564 "frontend/machine/pentium/decoder.m"
41819       
41820 
41821             stmts = instantiate(pc,  "SUBiowb", DIS_EADDR16, DIS_I8);
41822 
41823       
41824 
41825       
41826       
41827       
41828     } 
41829     goto MATCH_finished_c; 
41830     
41831   MATCH_label_c278: (void)0; /*placeholder for label*/ 
41832     { 
41833       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41834       int /* [~128..127] */ i8 = 
41835         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
41836       nextPC = 5 + MATCH_p; 
41837       
41838 #line 1564 "frontend/machine/pentium/decoder.m"
41839       
41840 
41841             stmts = instantiate(pc,  "SUBiowb", DIS_EADDR16, DIS_I8);
41842 
41843       
41844 
41845       
41846       
41847       
41848     } 
41849     goto MATCH_finished_c; 
41850     
41851   MATCH_label_c279: (void)0; /*placeholder for label*/ 
41852     { 
41853       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41854       int /* [~128..127] */ i8 = 
41855         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
41856       nextPC = 9 + MATCH_p; 
41857       
41858 #line 1564 "frontend/machine/pentium/decoder.m"
41859       
41860 
41861             stmts = instantiate(pc,  "SUBiowb", DIS_EADDR16, DIS_I8);
41862 
41863       
41864 
41865       
41866       
41867       
41868     } 
41869     goto MATCH_finished_c; 
41870     
41871   MATCH_label_c280: (void)0; /*placeholder for label*/ 
41872     { 
41873       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41874       int /* [~128..127] */ i8 = 
41875         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
41876       nextPC = 8 + MATCH_p; 
41877       
41878 #line 1564 "frontend/machine/pentium/decoder.m"
41879       
41880 
41881             stmts = instantiate(pc,  "SUBiowb", DIS_EADDR16, DIS_I8);
41882 
41883       
41884 
41885       
41886       
41887       
41888     } 
41889     goto MATCH_finished_c; 
41890     
41891   MATCH_label_c281: (void)0; /*placeholder for label*/ 
41892     { 
41893       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41894       int /* [~128..127] */ i8 = 
41895         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
41896       nextPC = 4 + MATCH_p; 
41897       
41898 #line 1558 "frontend/machine/pentium/decoder.m"
41899       
41900 
41901             stmts = instantiate(pc,  "XORiowb", DIS_EADDR16, DIS_I8);
41902 
41903       
41904 
41905       
41906       
41907       
41908     } 
41909     goto MATCH_finished_c; 
41910     
41911   MATCH_label_c282: (void)0; /*placeholder for label*/ 
41912     { 
41913       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41914       int /* [~128..127] */ i8 = 
41915         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
41916       nextPC = 5 + MATCH_p; 
41917       
41918 #line 1558 "frontend/machine/pentium/decoder.m"
41919       
41920 
41921             stmts = instantiate(pc,  "XORiowb", DIS_EADDR16, DIS_I8);
41922 
41923       
41924 
41925       
41926       
41927       
41928     } 
41929     goto MATCH_finished_c; 
41930     
41931   MATCH_label_c283: (void)0; /*placeholder for label*/ 
41932     { 
41933       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41934       int /* [~128..127] */ i8 = 
41935         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
41936       nextPC = 9 + MATCH_p; 
41937       
41938 #line 1558 "frontend/machine/pentium/decoder.m"
41939       
41940 
41941             stmts = instantiate(pc,  "XORiowb", DIS_EADDR16, DIS_I8);
41942 
41943       
41944 
41945       
41946       
41947       
41948     } 
41949     goto MATCH_finished_c; 
41950     
41951   MATCH_label_c284: (void)0; /*placeholder for label*/ 
41952     { 
41953       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41954       int /* [~128..127] */ i8 = 
41955         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
41956       nextPC = 8 + MATCH_p; 
41957       
41958 #line 1558 "frontend/machine/pentium/decoder.m"
41959       
41960 
41961             stmts = instantiate(pc,  "XORiowb", DIS_EADDR16, DIS_I8);
41962 
41963       
41964 
41965       
41966       
41967       
41968     } 
41969     goto MATCH_finished_c; 
41970     
41971   MATCH_label_c285: (void)0; /*placeholder for label*/ 
41972     { 
41973       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41974       int /* [~128..127] */ i8 = 
41975         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
41976       nextPC = 4 + MATCH_p; 
41977       
41978 #line 1552 "frontend/machine/pentium/decoder.m"
41979       
41980 
41981             stmts = instantiate(pc,  "CMPiowb", DIS_EADDR16, DIS_I8);
41982 
41983       
41984 
41985       
41986       
41987       
41988     } 
41989     goto MATCH_finished_c; 
41990     
41991   MATCH_label_c286: (void)0; /*placeholder for label*/ 
41992     { 
41993       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41994       int /* [~128..127] */ i8 = 
41995         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
41996       nextPC = 5 + MATCH_p; 
41997       
41998 #line 1552 "frontend/machine/pentium/decoder.m"
41999       
42000 
42001             stmts = instantiate(pc,  "CMPiowb", DIS_EADDR16, DIS_I8);
42002 
42003       
42004 
42005       
42006       
42007       
42008     } 
42009     goto MATCH_finished_c; 
42010     
42011   MATCH_label_c287: (void)0; /*placeholder for label*/ 
42012     { 
42013       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42014       int /* [~128..127] */ i8 = 
42015         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
42016       nextPC = 9 + MATCH_p; 
42017       
42018 #line 1552 "frontend/machine/pentium/decoder.m"
42019       
42020 
42021             stmts = instantiate(pc,  "CMPiowb", DIS_EADDR16, DIS_I8);
42022 
42023       
42024 
42025       
42026       
42027       
42028     } 
42029     goto MATCH_finished_c; 
42030     
42031   MATCH_label_c288: (void)0; /*placeholder for label*/ 
42032     { 
42033       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42034       int /* [~128..127] */ i8 = 
42035         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
42036       nextPC = 8 + MATCH_p; 
42037       
42038 #line 1552 "frontend/machine/pentium/decoder.m"
42039       
42040 
42041             stmts = instantiate(pc,  "CMPiowb", DIS_EADDR16, DIS_I8);
42042 
42043       
42044 
42045       
42046       
42047       
42048     } 
42049     goto MATCH_finished_c; 
42050     
42051   MATCH_label_c289: (void)0; /*placeholder for label*/ 
42052     { 
42053       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42054       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42055       nextPC = 3 + MATCH_p; 
42056       
42057 #line 1025 "frontend/machine/pentium/decoder.m"
42058       
42059 
42060             stmts = instantiate(pc,  "MOVrmow", DIS_REG16, DIS_EADDR16);
42061 
42062       
42063 
42064       
42065       
42066       
42067     } 
42068     goto MATCH_finished_c; 
42069     
42070   MATCH_label_c290: (void)0; /*placeholder for label*/ 
42071     { 
42072       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42073       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42074       nextPC = 4 + MATCH_p; 
42075       
42076 #line 1025 "frontend/machine/pentium/decoder.m"
42077       
42078 
42079             stmts = instantiate(pc,  "MOVrmow", DIS_REG16, DIS_EADDR16);
42080 
42081       
42082 
42083       
42084       
42085       
42086     } 
42087     goto MATCH_finished_c; 
42088     
42089   MATCH_label_c291: (void)0; /*placeholder for label*/ 
42090     { 
42091       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42092       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42093       nextPC = 8 + MATCH_p; 
42094       
42095 #line 1025 "frontend/machine/pentium/decoder.m"
42096       
42097 
42098             stmts = instantiate(pc,  "MOVrmow", DIS_REG16, DIS_EADDR16);
42099 
42100       
42101 
42102       
42103       
42104       
42105     } 
42106     goto MATCH_finished_c; 
42107     
42108   MATCH_label_c292: (void)0; /*placeholder for label*/ 
42109     { 
42110       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42111       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42112       nextPC = 7 + MATCH_p; 
42113       
42114 #line 1025 "frontend/machine/pentium/decoder.m"
42115       
42116 
42117             stmts = instantiate(pc,  "MOVrmow", DIS_REG16, DIS_EADDR16);
42118 
42119       
42120 
42121       
42122       
42123       
42124     } 
42125     goto MATCH_finished_c; 
42126     
42127   MATCH_label_c293: (void)0; /*placeholder for label*/ 
42128     { 
42129       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42130       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42131       nextPC = 3 + MATCH_p; 
42132       
42133 #line 381 "frontend/machine/pentium/decoder.m"
42134       
42135 
42136             stmts = instantiate(pc,  "TEST.Ev.Gvow", DIS_EADDR16, DIS_REG16);
42137 
42138       
42139 
42140       
42141       
42142       
42143     } 
42144     goto MATCH_finished_c; 
42145     
42146   MATCH_label_c294: (void)0; /*placeholder for label*/ 
42147     { 
42148       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42149       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42150       nextPC = 4 + MATCH_p; 
42151       
42152 #line 381 "frontend/machine/pentium/decoder.m"
42153       
42154 
42155             stmts = instantiate(pc,  "TEST.Ev.Gvow", DIS_EADDR16, DIS_REG16);
42156 
42157       
42158 
42159       
42160       
42161       
42162     } 
42163     goto MATCH_finished_c; 
42164     
42165   MATCH_label_c295: (void)0; /*placeholder for label*/ 
42166     { 
42167       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42168       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42169       nextPC = 8 + MATCH_p; 
42170       
42171 #line 381 "frontend/machine/pentium/decoder.m"
42172       
42173 
42174             stmts = instantiate(pc,  "TEST.Ev.Gvow", DIS_EADDR16, DIS_REG16);
42175 
42176       
42177 
42178       
42179       
42180       
42181     } 
42182     goto MATCH_finished_c; 
42183     
42184   MATCH_label_c296: (void)0; /*placeholder for label*/ 
42185     { 
42186       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42187       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42188       nextPC = 7 + MATCH_p; 
42189       
42190 #line 381 "frontend/machine/pentium/decoder.m"
42191       
42192 
42193             stmts = instantiate(pc,  "TEST.Ev.Gvow", DIS_EADDR16, DIS_REG16);
42194 
42195       
42196 
42197       
42198       
42199       
42200     } 
42201     goto MATCH_finished_c; 
42202     
42203   MATCH_label_c297: (void)0; /*placeholder for label*/ 
42204     { 
42205       unsigned Mem = 2 + addressToPC(MATCH_p);
42206       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42207       nextPC = 4 + MATCH_p; 
42208       
42209 #line 1076 "frontend/machine/pentium/decoder.m"
42210       
42211 
42212             stmts = instantiate(pc,  "LEA.ow", DIS_REG16, DIS_MEM);
42213 
42214       
42215 
42216       
42217       
42218       
42219     } 
42220     goto MATCH_finished_c; 
42221     
42222   MATCH_label_c298: (void)0; /*placeholder for label*/ 
42223     { 
42224       unsigned Mem = 2 + addressToPC(MATCH_p);
42225       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42226       nextPC = 8 + MATCH_p; 
42227       
42228 #line 1076 "frontend/machine/pentium/decoder.m"
42229       
42230 
42231             stmts = instantiate(pc,  "LEA.ow", DIS_REG16, DIS_MEM);
42232 
42233       
42234 
42235       
42236       
42237       
42238     } 
42239     goto MATCH_finished_c; 
42240     
42241   MATCH_label_c299: (void)0; /*placeholder for label*/ 
42242     { 
42243       unsigned Mem = 2 + addressToPC(MATCH_p);
42244       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42245       nextPC = 7 + MATCH_p; 
42246       
42247 #line 1076 "frontend/machine/pentium/decoder.m"
42248       
42249 
42250             stmts = instantiate(pc,  "LEA.ow", DIS_REG16, DIS_MEM);
42251 
42252       
42253 
42254       
42255       
42256       
42257     } 
42258     goto MATCH_finished_c; 
42259     
42260   MATCH_label_c300: (void)0; /*placeholder for label*/ 
42261     { 
42262       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42263       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42264       nextPC = 3 + MATCH_p; 
42265       
42266 #line 321 "frontend/machine/pentium/decoder.m"
42267       
42268 
42269             stmts = instantiate(pc,  "XCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
42270 
42271       
42272 
42273       
42274       
42275       
42276     } 
42277     goto MATCH_finished_c; 
42278     
42279   MATCH_label_c301: (void)0; /*placeholder for label*/ 
42280     { 
42281       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42282       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42283       nextPC = 4 + MATCH_p; 
42284       
42285 #line 321 "frontend/machine/pentium/decoder.m"
42286       
42287 
42288             stmts = instantiate(pc,  "XCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
42289 
42290       
42291 
42292       
42293       
42294       
42295     } 
42296     goto MATCH_finished_c; 
42297     
42298   MATCH_label_c302: (void)0; /*placeholder for label*/ 
42299     { 
42300       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42301       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42302       nextPC = 8 + MATCH_p; 
42303       
42304 #line 321 "frontend/machine/pentium/decoder.m"
42305       
42306 
42307             stmts = instantiate(pc,  "XCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
42308 
42309       
42310 
42311       
42312       
42313       
42314     } 
42315     goto MATCH_finished_c; 
42316     
42317   MATCH_label_c303: (void)0; /*placeholder for label*/ 
42318     { 
42319       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42320       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42321       nextPC = 7 + MATCH_p; 
42322       
42323 #line 321 "frontend/machine/pentium/decoder.m"
42324       
42325 
42326             stmts = instantiate(pc,  "XCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
42327 
42328       
42329 
42330       
42331       
42332       
42333     } 
42334     goto MATCH_finished_c; 
42335     
42336   MATCH_label_c304: (void)0; /*placeholder for label*/ 
42337     { 
42338       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42339       nextPC = 3 + MATCH_p; 
42340       
42341 #line 880 "frontend/machine/pentium/decoder.m"
42342       
42343 
42344             stmts = instantiate(pc,  "POP.Evow", DIS_EADDR16);
42345 
42346       
42347 
42348       //      | OUTSvod() =>
42349 
42350       //          stmts = instantiate(pc,  "OUTSvod");
42351 
42352       
42353 
42354       //      | OUTSvow() =>
42355 
42356       //          stmts = instantiate(pc,  "OUTSvow");
42357 
42358       
42359 
42360       //      | OUTSB() =>
42361 
42362       //          stmts = instantiate(pc,  "OUTSB");
42363 
42364       
42365 
42366       //      | OUT.DX.eAXod() =>
42367 
42368       //          stmts = instantiate(pc,  "OUT.DX.eAXod");
42369 
42370       
42371 
42372       //      | OUT.DX.eAXow() =>
42373 
42374       //          stmts = instantiate(pc,  "OUT.DX.eAXow");
42375 
42376       
42377 
42378       //      | OUT.DX.AL() =>
42379 
42380       //          stmts = instantiate(pc,  "OUT.DX.AL");
42381 
42382       
42383 
42384       //      | OUT.Ib.eAXod(i8) =>
42385 
42386       //          stmts = instantiate(pc,  "OUT.Ib.eAXod", DIS_I8);
42387 
42388       
42389 
42390       //      | OUT.Ib.eAXow(i8) =>
42391 
42392       //          stmts = instantiate(pc,  "OUT.Ib.eAXow", DIS_I8);
42393 
42394       
42395 
42396       //      | OUT.Ib.AL(i8) =>
42397 
42398       //          stmts = instantiate(pc,  "OUT.Ib.AL", DIS_I8);
42399 
42400       
42401 
42402       
42403       
42404       
42405     } 
42406     goto MATCH_finished_c; 
42407     
42408   MATCH_label_c305: (void)0; /*placeholder for label*/ 
42409     { 
42410       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42411       nextPC = 4 + MATCH_p; 
42412       
42413 #line 880 "frontend/machine/pentium/decoder.m"
42414       
42415 
42416             stmts = instantiate(pc,  "POP.Evow", DIS_EADDR16);
42417 
42418       
42419 
42420       //      | OUTSvod() =>
42421 
42422       //          stmts = instantiate(pc,  "OUTSvod");
42423 
42424       
42425 
42426       //      | OUTSvow() =>
42427 
42428       //          stmts = instantiate(pc,  "OUTSvow");
42429 
42430       
42431 
42432       //      | OUTSB() =>
42433 
42434       //          stmts = instantiate(pc,  "OUTSB");
42435 
42436       
42437 
42438       //      | OUT.DX.eAXod() =>
42439 
42440       //          stmts = instantiate(pc,  "OUT.DX.eAXod");
42441 
42442       
42443 
42444       //      | OUT.DX.eAXow() =>
42445 
42446       //          stmts = instantiate(pc,  "OUT.DX.eAXow");
42447 
42448       
42449 
42450       //      | OUT.DX.AL() =>
42451 
42452       //          stmts = instantiate(pc,  "OUT.DX.AL");
42453 
42454       
42455 
42456       //      | OUT.Ib.eAXod(i8) =>
42457 
42458       //          stmts = instantiate(pc,  "OUT.Ib.eAXod", DIS_I8);
42459 
42460       
42461 
42462       //      | OUT.Ib.eAXow(i8) =>
42463 
42464       //          stmts = instantiate(pc,  "OUT.Ib.eAXow", DIS_I8);
42465 
42466       
42467 
42468       //      | OUT.Ib.AL(i8) =>
42469 
42470       //          stmts = instantiate(pc,  "OUT.Ib.AL", DIS_I8);
42471 
42472       
42473 
42474       
42475       
42476       
42477     } 
42478     goto MATCH_finished_c; 
42479     
42480   MATCH_label_c306: (void)0; /*placeholder for label*/ 
42481     { 
42482       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42483       nextPC = 8 + MATCH_p; 
42484       
42485 #line 880 "frontend/machine/pentium/decoder.m"
42486       
42487 
42488             stmts = instantiate(pc,  "POP.Evow", DIS_EADDR16);
42489 
42490       
42491 
42492       //      | OUTSvod() =>
42493 
42494       //          stmts = instantiate(pc,  "OUTSvod");
42495 
42496       
42497 
42498       //      | OUTSvow() =>
42499 
42500       //          stmts = instantiate(pc,  "OUTSvow");
42501 
42502       
42503 
42504       //      | OUTSB() =>
42505 
42506       //          stmts = instantiate(pc,  "OUTSB");
42507 
42508       
42509 
42510       //      | OUT.DX.eAXod() =>
42511 
42512       //          stmts = instantiate(pc,  "OUT.DX.eAXod");
42513 
42514       
42515 
42516       //      | OUT.DX.eAXow() =>
42517 
42518       //          stmts = instantiate(pc,  "OUT.DX.eAXow");
42519 
42520       
42521 
42522       //      | OUT.DX.AL() =>
42523 
42524       //          stmts = instantiate(pc,  "OUT.DX.AL");
42525 
42526       
42527 
42528       //      | OUT.Ib.eAXod(i8) =>
42529 
42530       //          stmts = instantiate(pc,  "OUT.Ib.eAXod", DIS_I8);
42531 
42532       
42533 
42534       //      | OUT.Ib.eAXow(i8) =>
42535 
42536       //          stmts = instantiate(pc,  "OUT.Ib.eAXow", DIS_I8);
42537 
42538       
42539 
42540       //      | OUT.Ib.AL(i8) =>
42541 
42542       //          stmts = instantiate(pc,  "OUT.Ib.AL", DIS_I8);
42543 
42544       
42545 
42546       
42547       
42548       
42549     } 
42550     goto MATCH_finished_c; 
42551     
42552   MATCH_label_c307: (void)0; /*placeholder for label*/ 
42553     { 
42554       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42555       nextPC = 7 + MATCH_p; 
42556       
42557 #line 880 "frontend/machine/pentium/decoder.m"
42558       
42559 
42560             stmts = instantiate(pc,  "POP.Evow", DIS_EADDR16);
42561 
42562       
42563 
42564       //      | OUTSvod() =>
42565 
42566       //          stmts = instantiate(pc,  "OUTSvod");
42567 
42568       
42569 
42570       //      | OUTSvow() =>
42571 
42572       //          stmts = instantiate(pc,  "OUTSvow");
42573 
42574       
42575 
42576       //      | OUTSB() =>
42577 
42578       //          stmts = instantiate(pc,  "OUTSB");
42579 
42580       
42581 
42582       //      | OUT.DX.eAXod() =>
42583 
42584       //          stmts = instantiate(pc,  "OUT.DX.eAXod");
42585 
42586       
42587 
42588       //      | OUT.DX.eAXow() =>
42589 
42590       //          stmts = instantiate(pc,  "OUT.DX.eAXow");
42591 
42592       
42593 
42594       //      | OUT.DX.AL() =>
42595 
42596       //          stmts = instantiate(pc,  "OUT.DX.AL");
42597 
42598       
42599 
42600       //      | OUT.Ib.eAXod(i8) =>
42601 
42602       //          stmts = instantiate(pc,  "OUT.Ib.eAXod", DIS_I8);
42603 
42604       
42605 
42606       //      | OUT.Ib.eAXow(i8) =>
42607 
42608       //          stmts = instantiate(pc,  "OUT.Ib.eAXow", DIS_I8);
42609 
42610       
42611 
42612       //      | OUT.Ib.AL(i8) =>
42613 
42614       //          stmts = instantiate(pc,  "OUT.Ib.AL", DIS_I8);
42615 
42616       
42617 
42618       
42619       
42620       
42621     } 
42622     goto MATCH_finished_c; 
42623     
42624   MATCH_label_c308: (void)0; /*placeholder for label*/ 
42625     { 
42626       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42627       int /* [~128..127] */ i8 = 
42628         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
42629       nextPC = 4 + MATCH_p; 
42630       
42631 #line 638 "frontend/machine/pentium/decoder.m"
42632       
42633 
42634             stmts = instantiate(pc,  "ROLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
42635 
42636       
42637 
42638       
42639       
42640       
42641     } 
42642     goto MATCH_finished_c; 
42643     
42644   MATCH_label_c309: (void)0; /*placeholder for label*/ 
42645     { 
42646       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42647       int /* [~128..127] */ i8 = 
42648         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
42649       nextPC = 5 + MATCH_p; 
42650       
42651 #line 638 "frontend/machine/pentium/decoder.m"
42652       
42653 
42654             stmts = instantiate(pc,  "ROLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
42655 
42656       
42657 
42658       
42659       
42660       
42661     } 
42662     goto MATCH_finished_c; 
42663     
42664   MATCH_label_c310: (void)0; /*placeholder for label*/ 
42665     { 
42666       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42667       int /* [~128..127] */ i8 = 
42668         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
42669       nextPC = 9 + MATCH_p; 
42670       
42671 #line 638 "frontend/machine/pentium/decoder.m"
42672       
42673 
42674             stmts = instantiate(pc,  "ROLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
42675 
42676       
42677 
42678       
42679       
42680       
42681     } 
42682     goto MATCH_finished_c; 
42683     
42684   MATCH_label_c311: (void)0; /*placeholder for label*/ 
42685     { 
42686       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42687       int /* [~128..127] */ i8 = 
42688         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
42689       nextPC = 8 + MATCH_p; 
42690       
42691 #line 638 "frontend/machine/pentium/decoder.m"
42692       
42693 
42694             stmts = instantiate(pc,  "ROLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
42695 
42696       
42697 
42698       
42699       
42700       
42701     } 
42702     goto MATCH_finished_c; 
42703     
42704   MATCH_label_c312: (void)0; /*placeholder for label*/ 
42705     { 
42706       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42707       int /* [~128..127] */ i8 = 
42708         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
42709       nextPC = 4 + MATCH_p; 
42710       
42711 #line 632 "frontend/machine/pentium/decoder.m"
42712       
42713 
42714             stmts = instantiate(pc,  "RORB.Ev.Ibow", DIS_EADDR16, DIS_I8);
42715 
42716       
42717 
42718       
42719       
42720       
42721     } 
42722     goto MATCH_finished_c; 
42723     
42724   MATCH_label_c313: (void)0; /*placeholder for label*/ 
42725     { 
42726       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42727       int /* [~128..127] */ i8 = 
42728         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
42729       nextPC = 5 + MATCH_p; 
42730       
42731 #line 632 "frontend/machine/pentium/decoder.m"
42732       
42733 
42734             stmts = instantiate(pc,  "RORB.Ev.Ibow", DIS_EADDR16, DIS_I8);
42735 
42736       
42737 
42738       
42739       
42740       
42741     } 
42742     goto MATCH_finished_c; 
42743     
42744   MATCH_label_c314: (void)0; /*placeholder for label*/ 
42745     { 
42746       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42747       int /* [~128..127] */ i8 = 
42748         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
42749       nextPC = 9 + MATCH_p; 
42750       
42751 #line 632 "frontend/machine/pentium/decoder.m"
42752       
42753 
42754             stmts = instantiate(pc,  "RORB.Ev.Ibow", DIS_EADDR16, DIS_I8);
42755 
42756       
42757 
42758       
42759       
42760       
42761     } 
42762     goto MATCH_finished_c; 
42763     
42764   MATCH_label_c315: (void)0; /*placeholder for label*/ 
42765     { 
42766       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42767       int /* [~128..127] */ i8 = 
42768         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
42769       nextPC = 8 + MATCH_p; 
42770       
42771 #line 632 "frontend/machine/pentium/decoder.m"
42772       
42773 
42774             stmts = instantiate(pc,  "RORB.Ev.Ibow", DIS_EADDR16, DIS_I8);
42775 
42776       
42777 
42778       
42779       
42780       
42781     } 
42782     goto MATCH_finished_c; 
42783     
42784   MATCH_label_c316: (void)0; /*placeholder for label*/ 
42785     { 
42786       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42787       int /* [~128..127] */ i8 = 
42788         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
42789       nextPC = 4 + MATCH_p; 
42790       
42791 #line 626 "frontend/machine/pentium/decoder.m"
42792       
42793 
42794             stmts = instantiate(pc,  "RCLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
42795 
42796       
42797 
42798       
42799       
42800       
42801     } 
42802     goto MATCH_finished_c; 
42803     
42804   MATCH_label_c317: (void)0; /*placeholder for label*/ 
42805     { 
42806       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42807       int /* [~128..127] */ i8 = 
42808         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
42809       nextPC = 5 + MATCH_p; 
42810       
42811 #line 626 "frontend/machine/pentium/decoder.m"
42812       
42813 
42814             stmts = instantiate(pc,  "RCLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
42815 
42816       
42817 
42818       
42819       
42820       
42821     } 
42822     goto MATCH_finished_c; 
42823     
42824   MATCH_label_c318: (void)0; /*placeholder for label*/ 
42825     { 
42826       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42827       int /* [~128..127] */ i8 = 
42828         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
42829       nextPC = 9 + MATCH_p; 
42830       
42831 #line 626 "frontend/machine/pentium/decoder.m"
42832       
42833 
42834             stmts = instantiate(pc,  "RCLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
42835 
42836       
42837 
42838       
42839       
42840       
42841     } 
42842     goto MATCH_finished_c; 
42843     
42844   MATCH_label_c319: (void)0; /*placeholder for label*/ 
42845     { 
42846       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42847       int /* [~128..127] */ i8 = 
42848         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
42849       nextPC = 8 + MATCH_p; 
42850       
42851 #line 626 "frontend/machine/pentium/decoder.m"
42852       
42853 
42854             stmts = instantiate(pc,  "RCLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
42855 
42856       
42857 
42858       
42859       
42860       
42861     } 
42862     goto MATCH_finished_c; 
42863     
42864   MATCH_label_c320: (void)0; /*placeholder for label*/ 
42865     { 
42866       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42867       int /* [~128..127] */ i8 = 
42868         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
42869       nextPC = 4 + MATCH_p; 
42870       
42871 #line 620 "frontend/machine/pentium/decoder.m"
42872       
42873 
42874             stmts = instantiate(pc,  "RCRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
42875 
42876       
42877 
42878       
42879       
42880       
42881     } 
42882     goto MATCH_finished_c; 
42883     
42884   MATCH_label_c321: (void)0; /*placeholder for label*/ 
42885     { 
42886       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42887       int /* [~128..127] */ i8 = 
42888         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
42889       nextPC = 5 + MATCH_p; 
42890       
42891 #line 620 "frontend/machine/pentium/decoder.m"
42892       
42893 
42894             stmts = instantiate(pc,  "RCRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
42895 
42896       
42897 
42898       
42899       
42900       
42901     } 
42902     goto MATCH_finished_c; 
42903     
42904   MATCH_label_c322: (void)0; /*placeholder for label*/ 
42905     { 
42906       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42907       int /* [~128..127] */ i8 = 
42908         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
42909       nextPC = 9 + MATCH_p; 
42910       
42911 #line 620 "frontend/machine/pentium/decoder.m"
42912       
42913 
42914             stmts = instantiate(pc,  "RCRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
42915 
42916       
42917 
42918       
42919       
42920       
42921     } 
42922     goto MATCH_finished_c; 
42923     
42924   MATCH_label_c323: (void)0; /*placeholder for label*/ 
42925     { 
42926       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42927       int /* [~128..127] */ i8 = 
42928         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
42929       nextPC = 8 + MATCH_p; 
42930       
42931 #line 620 "frontend/machine/pentium/decoder.m"
42932       
42933 
42934             stmts = instantiate(pc,  "RCRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
42935 
42936       
42937 
42938       
42939       
42940       
42941     } 
42942     goto MATCH_finished_c; 
42943     
42944   MATCH_label_c324: (void)0; /*placeholder for label*/ 
42945     { 
42946       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42947       int /* [~128..127] */ i8 = 
42948         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
42949       nextPC = 4 + MATCH_p; 
42950       
42951 #line 614 "frontend/machine/pentium/decoder.m"
42952       
42953 
42954             stmts = instantiate(pc,  "SHLSALB.Ev.Ibow", DIS_EADDR16, DIS_I8);
42955 
42956       
42957 
42958       
42959       
42960       
42961     } 
42962     goto MATCH_finished_c; 
42963     
42964   MATCH_label_c325: (void)0; /*placeholder for label*/ 
42965     { 
42966       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42967       int /* [~128..127] */ i8 = 
42968         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
42969       nextPC = 5 + MATCH_p; 
42970       
42971 #line 614 "frontend/machine/pentium/decoder.m"
42972       
42973 
42974             stmts = instantiate(pc,  "SHLSALB.Ev.Ibow", DIS_EADDR16, DIS_I8);
42975 
42976       
42977 
42978       
42979       
42980       
42981     } 
42982     goto MATCH_finished_c; 
42983     
42984   MATCH_label_c326: (void)0; /*placeholder for label*/ 
42985     { 
42986       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42987       int /* [~128..127] */ i8 = 
42988         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
42989       nextPC = 9 + MATCH_p; 
42990       
42991 #line 614 "frontend/machine/pentium/decoder.m"
42992       
42993 
42994             stmts = instantiate(pc,  "SHLSALB.Ev.Ibow", DIS_EADDR16, DIS_I8);
42995 
42996       
42997 
42998       
42999       
43000       
43001     } 
43002     goto MATCH_finished_c; 
43003     
43004   MATCH_label_c327: (void)0; /*placeholder for label*/ 
43005     { 
43006       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43007       int /* [~128..127] */ i8 = 
43008         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
43009       nextPC = 8 + MATCH_p; 
43010       
43011 #line 614 "frontend/machine/pentium/decoder.m"
43012       
43013 
43014             stmts = instantiate(pc,  "SHLSALB.Ev.Ibow", DIS_EADDR16, DIS_I8);
43015 
43016       
43017 
43018       
43019       
43020       
43021     } 
43022     goto MATCH_finished_c; 
43023     
43024   MATCH_label_c328: (void)0; /*placeholder for label*/ 
43025     { 
43026       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43027       int /* [~128..127] */ i8 = 
43028         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
43029       nextPC = 4 + MATCH_p; 
43030       
43031 #line 608 "frontend/machine/pentium/decoder.m"
43032       
43033 
43034             stmts = instantiate(pc,  "SHRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
43035 
43036       
43037 
43038       
43039       
43040       
43041     } 
43042     goto MATCH_finished_c; 
43043     
43044   MATCH_label_c329: (void)0; /*placeholder for label*/ 
43045     { 
43046       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43047       int /* [~128..127] */ i8 = 
43048         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
43049       nextPC = 5 + MATCH_p; 
43050       
43051 #line 608 "frontend/machine/pentium/decoder.m"
43052       
43053 
43054             stmts = instantiate(pc,  "SHRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
43055 
43056       
43057 
43058       
43059       
43060       
43061     } 
43062     goto MATCH_finished_c; 
43063     
43064   MATCH_label_c330: (void)0; /*placeholder for label*/ 
43065     { 
43066       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43067       int /* [~128..127] */ i8 = 
43068         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
43069       nextPC = 9 + MATCH_p; 
43070       
43071 #line 608 "frontend/machine/pentium/decoder.m"
43072       
43073 
43074             stmts = instantiate(pc,  "SHRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
43075 
43076       
43077 
43078       
43079       
43080       
43081     } 
43082     goto MATCH_finished_c; 
43083     
43084   MATCH_label_c331: (void)0; /*placeholder for label*/ 
43085     { 
43086       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43087       int /* [~128..127] */ i8 = 
43088         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
43089       nextPC = 8 + MATCH_p; 
43090       
43091 #line 608 "frontend/machine/pentium/decoder.m"
43092       
43093 
43094             stmts = instantiate(pc,  "SHRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
43095 
43096       
43097 
43098       
43099       
43100       
43101     } 
43102     goto MATCH_finished_c; 
43103     
43104   MATCH_label_c332: (void)0; /*placeholder for label*/ 
43105     { 
43106       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43107       int /* [~128..127] */ i8 = 
43108         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
43109       nextPC = 4 + MATCH_p; 
43110       
43111 #line 602 "frontend/machine/pentium/decoder.m"
43112       
43113 
43114             stmts = instantiate(pc,  "SARB.Ev.Ibow", DIS_EADDR16, DIS_I8);
43115 
43116       
43117 
43118       
43119       
43120       
43121     } 
43122     goto MATCH_finished_c; 
43123     
43124   MATCH_label_c333: (void)0; /*placeholder for label*/ 
43125     { 
43126       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43127       int /* [~128..127] */ i8 = 
43128         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
43129       nextPC = 5 + MATCH_p; 
43130       
43131 #line 602 "frontend/machine/pentium/decoder.m"
43132       
43133 
43134             stmts = instantiate(pc,  "SARB.Ev.Ibow", DIS_EADDR16, DIS_I8);
43135 
43136       
43137 
43138       
43139       
43140       
43141     } 
43142     goto MATCH_finished_c; 
43143     
43144   MATCH_label_c334: (void)0; /*placeholder for label*/ 
43145     { 
43146       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43147       int /* [~128..127] */ i8 = 
43148         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
43149       nextPC = 9 + MATCH_p; 
43150       
43151 #line 602 "frontend/machine/pentium/decoder.m"
43152       
43153 
43154             stmts = instantiate(pc,  "SARB.Ev.Ibow", DIS_EADDR16, DIS_I8);
43155 
43156       
43157 
43158       
43159       
43160       
43161     } 
43162     goto MATCH_finished_c; 
43163     
43164   MATCH_label_c335: (void)0; /*placeholder for label*/ 
43165     { 
43166       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43167       int /* [~128..127] */ i8 = 
43168         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
43169       nextPC = 8 + MATCH_p; 
43170       
43171 #line 602 "frontend/machine/pentium/decoder.m"
43172       
43173 
43174             stmts = instantiate(pc,  "SARB.Ev.Ibow", DIS_EADDR16, DIS_I8);
43175 
43176       
43177 
43178       
43179       
43180       
43181     } 
43182     goto MATCH_finished_c; 
43183     
43184   MATCH_label_c336: (void)0; /*placeholder for label*/ 
43185     { 
43186       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43187       int /* [~32768..32767] */ i16 = 
43188         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
43189       nextPC = 5 + MATCH_p; 
43190       
43191 #line 983 "frontend/machine/pentium/decoder.m"
43192       
43193 
43194             stmts = instantiate(pc,  "MOV.Ew.Ivow", DIS_EADDR16, DIS_I16);
43195 
43196       
43197 
43198       
43199       
43200       
43201     } 
43202     goto MATCH_finished_c; 
43203     
43204   MATCH_label_c337: (void)0; /*placeholder for label*/ 
43205     { 
43206       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43207       int /* [~32768..32767] */ i16 = 
43208         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
43209       nextPC = 6 + MATCH_p; 
43210       
43211 #line 983 "frontend/machine/pentium/decoder.m"
43212       
43213 
43214             stmts = instantiate(pc,  "MOV.Ew.Ivow", DIS_EADDR16, DIS_I16);
43215 
43216       
43217 
43218       
43219       
43220       
43221     } 
43222     goto MATCH_finished_c; 
43223     
43224   MATCH_label_c338: (void)0; /*placeholder for label*/ 
43225     { 
43226       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43227       int /* [~32768..32767] */ i16 = 
43228         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
43229       nextPC = 10 + MATCH_p; 
43230       
43231 #line 983 "frontend/machine/pentium/decoder.m"
43232       
43233 
43234             stmts = instantiate(pc,  "MOV.Ew.Ivow", DIS_EADDR16, DIS_I16);
43235 
43236       
43237 
43238       
43239       
43240       
43241     } 
43242     goto MATCH_finished_c; 
43243     
43244   MATCH_label_c339: (void)0; /*placeholder for label*/ 
43245     { 
43246       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43247       int /* [~32768..32767] */ i16 = 
43248         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
43249       nextPC = 9 + MATCH_p; 
43250       
43251 #line 983 "frontend/machine/pentium/decoder.m"
43252       
43253 
43254             stmts = instantiate(pc,  "MOV.Ew.Ivow", DIS_EADDR16, DIS_I16);
43255 
43256       
43257 
43258       
43259       
43260       
43261     } 
43262     goto MATCH_finished_c; 
43263     
43264   MATCH_label_c340: (void)0; /*placeholder for label*/ 
43265     { 
43266       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43267       nextPC = 3 + MATCH_p; 
43268       
43269 #line 743 "frontend/machine/pentium/decoder.m"
43270       
43271 
43272             stmts = instantiate(pc,  "ROLB.Ev.1ow", DIS_EADDR16);
43273 
43274       
43275 
43276       
43277       
43278       
43279     } 
43280     goto MATCH_finished_c; 
43281     
43282   MATCH_label_c341: (void)0; /*placeholder for label*/ 
43283     { 
43284       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43285       nextPC = 4 + MATCH_p; 
43286       
43287 #line 743 "frontend/machine/pentium/decoder.m"
43288       
43289 
43290             stmts = instantiate(pc,  "ROLB.Ev.1ow", DIS_EADDR16);
43291 
43292       
43293 
43294       
43295       
43296       
43297     } 
43298     goto MATCH_finished_c; 
43299     
43300   MATCH_label_c342: (void)0; /*placeholder for label*/ 
43301     { 
43302       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43303       nextPC = 8 + MATCH_p; 
43304       
43305 #line 743 "frontend/machine/pentium/decoder.m"
43306       
43307 
43308             stmts = instantiate(pc,  "ROLB.Ev.1ow", DIS_EADDR16);
43309 
43310       
43311 
43312       
43313       
43314       
43315     } 
43316     goto MATCH_finished_c; 
43317     
43318   MATCH_label_c343: (void)0; /*placeholder for label*/ 
43319     { 
43320       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43321       nextPC = 7 + MATCH_p; 
43322       
43323 #line 743 "frontend/machine/pentium/decoder.m"
43324       
43325 
43326             stmts = instantiate(pc,  "ROLB.Ev.1ow", DIS_EADDR16);
43327 
43328       
43329 
43330       
43331       
43332       
43333     } 
43334     goto MATCH_finished_c; 
43335     
43336   MATCH_label_c344: (void)0; /*placeholder for label*/ 
43337     { 
43338       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43339       nextPC = 3 + MATCH_p; 
43340       
43341 #line 731 "frontend/machine/pentium/decoder.m"
43342       
43343 
43344             stmts = instantiate(pc,  "ORB.Ev.1owR", DIS_EADDR16);
43345 
43346       
43347 
43348       
43349       
43350       
43351     } 
43352     goto MATCH_finished_c; 
43353     
43354   MATCH_label_c345: (void)0; /*placeholder for label*/ 
43355     { 
43356       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43357       nextPC = 4 + MATCH_p; 
43358       
43359 #line 731 "frontend/machine/pentium/decoder.m"
43360       
43361 
43362             stmts = instantiate(pc,  "ORB.Ev.1owR", DIS_EADDR16);
43363 
43364       
43365 
43366       
43367       
43368       
43369     } 
43370     goto MATCH_finished_c; 
43371     
43372   MATCH_label_c346: (void)0; /*placeholder for label*/ 
43373     { 
43374       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43375       nextPC = 8 + MATCH_p; 
43376       
43377 #line 731 "frontend/machine/pentium/decoder.m"
43378       
43379 
43380             stmts = instantiate(pc,  "ORB.Ev.1owR", DIS_EADDR16);
43381 
43382       
43383 
43384       
43385       
43386       
43387     } 
43388     goto MATCH_finished_c; 
43389     
43390   MATCH_label_c347: (void)0; /*placeholder for label*/ 
43391     { 
43392       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43393       nextPC = 7 + MATCH_p; 
43394       
43395 #line 731 "frontend/machine/pentium/decoder.m"
43396       
43397 
43398             stmts = instantiate(pc,  "ORB.Ev.1owR", DIS_EADDR16);
43399 
43400       
43401 
43402       
43403       
43404       
43405     } 
43406     goto MATCH_finished_c; 
43407     
43408   MATCH_label_c348: (void)0; /*placeholder for label*/ 
43409     { 
43410       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43411       nextPC = 3 + MATCH_p; 
43412       
43413 #line 719 "frontend/machine/pentium/decoder.m"
43414       
43415 
43416             stmts = instantiate(pc,  "RCLB.Ev.1ow", DIS_EADDR16);
43417 
43418       
43419 
43420       
43421       
43422       
43423     } 
43424     goto MATCH_finished_c; 
43425     
43426   MATCH_label_c349: (void)0; /*placeholder for label*/ 
43427     { 
43428       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43429       nextPC = 4 + MATCH_p; 
43430       
43431 #line 719 "frontend/machine/pentium/decoder.m"
43432       
43433 
43434             stmts = instantiate(pc,  "RCLB.Ev.1ow", DIS_EADDR16);
43435 
43436       
43437 
43438       
43439       
43440       
43441     } 
43442     goto MATCH_finished_c; 
43443     
43444   MATCH_label_c350: (void)0; /*placeholder for label*/ 
43445     { 
43446       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43447       nextPC = 8 + MATCH_p; 
43448       
43449 #line 719 "frontend/machine/pentium/decoder.m"
43450       
43451 
43452             stmts = instantiate(pc,  "RCLB.Ev.1ow", DIS_EADDR16);
43453 
43454       
43455 
43456       
43457       
43458       
43459     } 
43460     goto MATCH_finished_c; 
43461     
43462   MATCH_label_c351: (void)0; /*placeholder for label*/ 
43463     { 
43464       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43465       nextPC = 7 + MATCH_p; 
43466       
43467 #line 719 "frontend/machine/pentium/decoder.m"
43468       
43469 
43470             stmts = instantiate(pc,  "RCLB.Ev.1ow", DIS_EADDR16);
43471 
43472       
43473 
43474       
43475       
43476       
43477     } 
43478     goto MATCH_finished_c; 
43479     
43480   MATCH_label_c352: (void)0; /*placeholder for label*/ 
43481     { 
43482       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43483       nextPC = 3 + MATCH_p; 
43484       
43485 #line 707 "frontend/machine/pentium/decoder.m"
43486       
43487 
43488             stmts = instantiate(pc,  "RCRB.Ev.1ow", DIS_EADDR16);
43489 
43490       
43491 
43492       
43493       
43494       
43495     } 
43496     goto MATCH_finished_c; 
43497     
43498   MATCH_label_c353: (void)0; /*placeholder for label*/ 
43499     { 
43500       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43501       nextPC = 4 + MATCH_p; 
43502       
43503 #line 707 "frontend/machine/pentium/decoder.m"
43504       
43505 
43506             stmts = instantiate(pc,  "RCRB.Ev.1ow", DIS_EADDR16);
43507 
43508       
43509 
43510       
43511       
43512       
43513     } 
43514     goto MATCH_finished_c; 
43515     
43516   MATCH_label_c354: (void)0; /*placeholder for label*/ 
43517     { 
43518       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43519       nextPC = 8 + MATCH_p; 
43520       
43521 #line 707 "frontend/machine/pentium/decoder.m"
43522       
43523 
43524             stmts = instantiate(pc,  "RCRB.Ev.1ow", DIS_EADDR16);
43525 
43526       
43527 
43528       
43529       
43530       
43531     } 
43532     goto MATCH_finished_c; 
43533     
43534   MATCH_label_c355: (void)0; /*placeholder for label*/ 
43535     { 
43536       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43537       nextPC = 7 + MATCH_p; 
43538       
43539 #line 707 "frontend/machine/pentium/decoder.m"
43540       
43541 
43542             stmts = instantiate(pc,  "RCRB.Ev.1ow", DIS_EADDR16);
43543 
43544       
43545 
43546       
43547       
43548       
43549     } 
43550     goto MATCH_finished_c; 
43551     
43552   MATCH_label_c356: (void)0; /*placeholder for label*/ 
43553     { 
43554       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43555       nextPC = 3 + MATCH_p; 
43556       
43557 #line 695 "frontend/machine/pentium/decoder.m"
43558       
43559 
43560             stmts = instantiate(pc,  "SHLSALB.Ev.1ow", DIS_EADDR16);
43561 
43562       
43563 
43564       
43565       
43566       
43567     } 
43568     goto MATCH_finished_c; 
43569     
43570   MATCH_label_c357: (void)0; /*placeholder for label*/ 
43571     { 
43572       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43573       nextPC = 4 + MATCH_p; 
43574       
43575 #line 695 "frontend/machine/pentium/decoder.m"
43576       
43577 
43578             stmts = instantiate(pc,  "SHLSALB.Ev.1ow", DIS_EADDR16);
43579 
43580       
43581 
43582       
43583       
43584       
43585     } 
43586     goto MATCH_finished_c; 
43587     
43588   MATCH_label_c358: (void)0; /*placeholder for label*/ 
43589     { 
43590       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43591       nextPC = 8 + MATCH_p; 
43592       
43593 #line 695 "frontend/machine/pentium/decoder.m"
43594       
43595 
43596             stmts = instantiate(pc,  "SHLSALB.Ev.1ow", DIS_EADDR16);
43597 
43598       
43599 
43600       
43601       
43602       
43603     } 
43604     goto MATCH_finished_c; 
43605     
43606   MATCH_label_c359: (void)0; /*placeholder for label*/ 
43607     { 
43608       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43609       nextPC = 7 + MATCH_p; 
43610       
43611 #line 695 "frontend/machine/pentium/decoder.m"
43612       
43613 
43614             stmts = instantiate(pc,  "SHLSALB.Ev.1ow", DIS_EADDR16);
43615 
43616       
43617 
43618       
43619       
43620       
43621     } 
43622     goto MATCH_finished_c; 
43623     
43624   MATCH_label_c360: (void)0; /*placeholder for label*/ 
43625     { 
43626       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43627       nextPC = 3 + MATCH_p; 
43628       
43629 #line 683 "frontend/machine/pentium/decoder.m"
43630       
43631 
43632             stmts = instantiate(pc,  "SHRB.Ev.1ow", DIS_EADDR16);
43633 
43634       
43635 
43636       
43637       
43638       
43639     } 
43640     goto MATCH_finished_c; 
43641     
43642   MATCH_label_c361: (void)0; /*placeholder for label*/ 
43643     { 
43644       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43645       nextPC = 4 + MATCH_p; 
43646       
43647 #line 683 "frontend/machine/pentium/decoder.m"
43648       
43649 
43650             stmts = instantiate(pc,  "SHRB.Ev.1ow", DIS_EADDR16);
43651 
43652       
43653 
43654       
43655       
43656       
43657     } 
43658     goto MATCH_finished_c; 
43659     
43660   MATCH_label_c362: (void)0; /*placeholder for label*/ 
43661     { 
43662       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43663       nextPC = 8 + MATCH_p; 
43664       
43665 #line 683 "frontend/machine/pentium/decoder.m"
43666       
43667 
43668             stmts = instantiate(pc,  "SHRB.Ev.1ow", DIS_EADDR16);
43669 
43670       
43671 
43672       
43673       
43674       
43675     } 
43676     goto MATCH_finished_c; 
43677     
43678   MATCH_label_c363: (void)0; /*placeholder for label*/ 
43679     { 
43680       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43681       nextPC = 7 + MATCH_p; 
43682       
43683 #line 683 "frontend/machine/pentium/decoder.m"
43684       
43685 
43686             stmts = instantiate(pc,  "SHRB.Ev.1ow", DIS_EADDR16);
43687 
43688       
43689 
43690       
43691       
43692       
43693     } 
43694     goto MATCH_finished_c; 
43695     
43696   MATCH_label_c364: (void)0; /*placeholder for label*/ 
43697     { 
43698       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43699       nextPC = 3 + MATCH_p; 
43700       
43701 #line 671 "frontend/machine/pentium/decoder.m"
43702       
43703 
43704             stmts = instantiate(pc,  "SARB.Ev.1ow", DIS_EADDR16);
43705 
43706       
43707 
43708       
43709       
43710       
43711     } 
43712     goto MATCH_finished_c; 
43713     
43714   MATCH_label_c365: (void)0; /*placeholder for label*/ 
43715     { 
43716       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43717       nextPC = 4 + MATCH_p; 
43718       
43719 #line 671 "frontend/machine/pentium/decoder.m"
43720       
43721 
43722             stmts = instantiate(pc,  "SARB.Ev.1ow", DIS_EADDR16);
43723 
43724       
43725 
43726       
43727       
43728       
43729     } 
43730     goto MATCH_finished_c; 
43731     
43732   MATCH_label_c366: (void)0; /*placeholder for label*/ 
43733     { 
43734       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43735       nextPC = 8 + MATCH_p; 
43736       
43737 #line 671 "frontend/machine/pentium/decoder.m"
43738       
43739 
43740             stmts = instantiate(pc,  "SARB.Ev.1ow", DIS_EADDR16);
43741 
43742       
43743 
43744       
43745       
43746       
43747     } 
43748     goto MATCH_finished_c; 
43749     
43750   MATCH_label_c367: (void)0; /*placeholder for label*/ 
43751     { 
43752       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43753       nextPC = 7 + MATCH_p; 
43754       
43755 #line 671 "frontend/machine/pentium/decoder.m"
43756       
43757 
43758             stmts = instantiate(pc,  "SARB.Ev.1ow", DIS_EADDR16);
43759 
43760       
43761 
43762       
43763       
43764       
43765     } 
43766     goto MATCH_finished_c; 
43767     
43768   MATCH_label_c368: (void)0; /*placeholder for label*/ 
43769     { 
43770       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43771       nextPC = 3 + MATCH_p; 
43772       
43773 #line 737 "frontend/machine/pentium/decoder.m"
43774       
43775 
43776             stmts = instantiate(pc,  "ROLB.Ev.CLow", DIS_EADDR16);
43777 
43778       
43779 
43780       
43781       
43782       
43783     } 
43784     goto MATCH_finished_c; 
43785     
43786   MATCH_label_c369: (void)0; /*placeholder for label*/ 
43787     { 
43788       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43789       nextPC = 4 + MATCH_p; 
43790       
43791 #line 737 "frontend/machine/pentium/decoder.m"
43792       
43793 
43794             stmts = instantiate(pc,  "ROLB.Ev.CLow", DIS_EADDR16);
43795 
43796       
43797 
43798       
43799       
43800       
43801     } 
43802     goto MATCH_finished_c; 
43803     
43804   MATCH_label_c370: (void)0; /*placeholder for label*/ 
43805     { 
43806       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43807       nextPC = 8 + MATCH_p; 
43808       
43809 #line 737 "frontend/machine/pentium/decoder.m"
43810       
43811 
43812             stmts = instantiate(pc,  "ROLB.Ev.CLow", DIS_EADDR16);
43813 
43814       
43815 
43816       
43817       
43818       
43819     } 
43820     goto MATCH_finished_c; 
43821     
43822   MATCH_label_c371: (void)0; /*placeholder for label*/ 
43823     { 
43824       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43825       nextPC = 7 + MATCH_p; 
43826       
43827 #line 737 "frontend/machine/pentium/decoder.m"
43828       
43829 
43830             stmts = instantiate(pc,  "ROLB.Ev.CLow", DIS_EADDR16);
43831 
43832       
43833 
43834       
43835       
43836       
43837     } 
43838     goto MATCH_finished_c; 
43839     
43840   MATCH_label_c372: (void)0; /*placeholder for label*/ 
43841     { 
43842       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43843       nextPC = 3 + MATCH_p; 
43844       
43845 #line 725 "frontend/machine/pentium/decoder.m"
43846       
43847 
43848             stmts = instantiate(pc,  "RORB.Ev.CLow", DIS_EADDR16);
43849 
43850       
43851 
43852       
43853       
43854       
43855     } 
43856     goto MATCH_finished_c; 
43857     
43858   MATCH_label_c373: (void)0; /*placeholder for label*/ 
43859     { 
43860       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43861       nextPC = 4 + MATCH_p; 
43862       
43863 #line 725 "frontend/machine/pentium/decoder.m"
43864       
43865 
43866             stmts = instantiate(pc,  "RORB.Ev.CLow", DIS_EADDR16);
43867 
43868       
43869 
43870       
43871       
43872       
43873     } 
43874     goto MATCH_finished_c; 
43875     
43876   MATCH_label_c374: (void)0; /*placeholder for label*/ 
43877     { 
43878       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43879       nextPC = 8 + MATCH_p; 
43880       
43881 #line 725 "frontend/machine/pentium/decoder.m"
43882       
43883 
43884             stmts = instantiate(pc,  "RORB.Ev.CLow", DIS_EADDR16);
43885 
43886       
43887 
43888       
43889       
43890       
43891     } 
43892     goto MATCH_finished_c; 
43893     
43894   MATCH_label_c375: (void)0; /*placeholder for label*/ 
43895     { 
43896       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43897       nextPC = 7 + MATCH_p; 
43898       
43899 #line 725 "frontend/machine/pentium/decoder.m"
43900       
43901 
43902             stmts = instantiate(pc,  "RORB.Ev.CLow", DIS_EADDR16);
43903 
43904       
43905 
43906       
43907       
43908       
43909     } 
43910     goto MATCH_finished_c; 
43911     
43912   MATCH_label_c376: (void)0; /*placeholder for label*/ 
43913     { 
43914       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43915       nextPC = 3 + MATCH_p; 
43916       
43917 #line 713 "frontend/machine/pentium/decoder.m"
43918       
43919 
43920             stmts = instantiate(pc,  "RCLB.Ev.CLow", DIS_EADDR16);
43921 
43922       
43923 
43924       
43925       
43926       
43927     } 
43928     goto MATCH_finished_c; 
43929     
43930   MATCH_label_c377: (void)0; /*placeholder for label*/ 
43931     { 
43932       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43933       nextPC = 4 + MATCH_p; 
43934       
43935 #line 713 "frontend/machine/pentium/decoder.m"
43936       
43937 
43938             stmts = instantiate(pc,  "RCLB.Ev.CLow", DIS_EADDR16);
43939 
43940       
43941 
43942       
43943       
43944       
43945     } 
43946     goto MATCH_finished_c; 
43947     
43948   MATCH_label_c378: (void)0; /*placeholder for label*/ 
43949     { 
43950       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43951       nextPC = 8 + MATCH_p; 
43952       
43953 #line 713 "frontend/machine/pentium/decoder.m"
43954       
43955 
43956             stmts = instantiate(pc,  "RCLB.Ev.CLow", DIS_EADDR16);
43957 
43958       
43959 
43960       
43961       
43962       
43963     } 
43964     goto MATCH_finished_c; 
43965     
43966   MATCH_label_c379: (void)0; /*placeholder for label*/ 
43967     { 
43968       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43969       nextPC = 7 + MATCH_p; 
43970       
43971 #line 713 "frontend/machine/pentium/decoder.m"
43972       
43973 
43974             stmts = instantiate(pc,  "RCLB.Ev.CLow", DIS_EADDR16);
43975 
43976       
43977 
43978       
43979       
43980       
43981     } 
43982     goto MATCH_finished_c; 
43983     
43984   MATCH_label_c380: (void)0; /*placeholder for label*/ 
43985     { 
43986       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43987       nextPC = 3 + MATCH_p; 
43988       
43989 #line 701 "frontend/machine/pentium/decoder.m"
43990       
43991 
43992             stmts = instantiate(pc,  "RCRB.Ev.CLow", DIS_EADDR16);
43993 
43994       
43995 
43996       
43997       
43998       
43999     } 
44000     goto MATCH_finished_c; 
44001     
44002   MATCH_label_c381: (void)0; /*placeholder for label*/ 
44003     { 
44004       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44005       nextPC = 4 + MATCH_p; 
44006       
44007 #line 701 "frontend/machine/pentium/decoder.m"
44008       
44009 
44010             stmts = instantiate(pc,  "RCRB.Ev.CLow", DIS_EADDR16);
44011 
44012       
44013 
44014       
44015       
44016       
44017     } 
44018     goto MATCH_finished_c; 
44019     
44020   MATCH_label_c382: (void)0; /*placeholder for label*/ 
44021     { 
44022       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44023       nextPC = 8 + MATCH_p; 
44024       
44025 #line 701 "frontend/machine/pentium/decoder.m"
44026       
44027 
44028             stmts = instantiate(pc,  "RCRB.Ev.CLow", DIS_EADDR16);
44029 
44030       
44031 
44032       
44033       
44034       
44035     } 
44036     goto MATCH_finished_c; 
44037     
44038   MATCH_label_c383: (void)0; /*placeholder for label*/ 
44039     { 
44040       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44041       nextPC = 7 + MATCH_p; 
44042       
44043 #line 701 "frontend/machine/pentium/decoder.m"
44044       
44045 
44046             stmts = instantiate(pc,  "RCRB.Ev.CLow", DIS_EADDR16);
44047 
44048       
44049 
44050       
44051       
44052       
44053     } 
44054     goto MATCH_finished_c; 
44055     
44056   MATCH_label_c384: (void)0; /*placeholder for label*/ 
44057     { 
44058       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44059       nextPC = 3 + MATCH_p; 
44060       
44061 #line 689 "frontend/machine/pentium/decoder.m"
44062       
44063 
44064             stmts = instantiate(pc,  "SHLSALB.Ev.CLow", DIS_EADDR16);
44065 
44066       
44067 
44068       
44069       
44070       
44071     } 
44072     goto MATCH_finished_c; 
44073     
44074   MATCH_label_c385: (void)0; /*placeholder for label*/ 
44075     { 
44076       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44077       nextPC = 4 + MATCH_p; 
44078       
44079 #line 689 "frontend/machine/pentium/decoder.m"
44080       
44081 
44082             stmts = instantiate(pc,  "SHLSALB.Ev.CLow", DIS_EADDR16);
44083 
44084       
44085 
44086       
44087       
44088       
44089     } 
44090     goto MATCH_finished_c; 
44091     
44092   MATCH_label_c386: (void)0; /*placeholder for label*/ 
44093     { 
44094       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44095       nextPC = 8 + MATCH_p; 
44096       
44097 #line 689 "frontend/machine/pentium/decoder.m"
44098       
44099 
44100             stmts = instantiate(pc,  "SHLSALB.Ev.CLow", DIS_EADDR16);
44101 
44102       
44103 
44104       
44105       
44106       
44107     } 
44108     goto MATCH_finished_c; 
44109     
44110   MATCH_label_c387: (void)0; /*placeholder for label*/ 
44111     { 
44112       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44113       nextPC = 7 + MATCH_p; 
44114       
44115 #line 689 "frontend/machine/pentium/decoder.m"
44116       
44117 
44118             stmts = instantiate(pc,  "SHLSALB.Ev.CLow", DIS_EADDR16);
44119 
44120       
44121 
44122       
44123       
44124       
44125     } 
44126     goto MATCH_finished_c; 
44127     
44128   MATCH_label_c388: (void)0; /*placeholder for label*/ 
44129     { 
44130       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44131       nextPC = 3 + MATCH_p; 
44132       
44133 #line 677 "frontend/machine/pentium/decoder.m"
44134       
44135 
44136             stmts = instantiate(pc,  "SHRB.Ev.CLow", DIS_EADDR16);
44137 
44138       
44139 
44140       
44141       
44142       
44143     } 
44144     goto MATCH_finished_c; 
44145     
44146   MATCH_label_c389: (void)0; /*placeholder for label*/ 
44147     { 
44148       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44149       nextPC = 4 + MATCH_p; 
44150       
44151 #line 677 "frontend/machine/pentium/decoder.m"
44152       
44153 
44154             stmts = instantiate(pc,  "SHRB.Ev.CLow", DIS_EADDR16);
44155 
44156       
44157 
44158       
44159       
44160       
44161     } 
44162     goto MATCH_finished_c; 
44163     
44164   MATCH_label_c390: (void)0; /*placeholder for label*/ 
44165     { 
44166       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44167       nextPC = 8 + MATCH_p; 
44168       
44169 #line 677 "frontend/machine/pentium/decoder.m"
44170       
44171 
44172             stmts = instantiate(pc,  "SHRB.Ev.CLow", DIS_EADDR16);
44173 
44174       
44175 
44176       
44177       
44178       
44179     } 
44180     goto MATCH_finished_c; 
44181     
44182   MATCH_label_c391: (void)0; /*placeholder for label*/ 
44183     { 
44184       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44185       nextPC = 7 + MATCH_p; 
44186       
44187 #line 677 "frontend/machine/pentium/decoder.m"
44188       
44189 
44190             stmts = instantiate(pc,  "SHRB.Ev.CLow", DIS_EADDR16);
44191 
44192       
44193 
44194       
44195       
44196       
44197     } 
44198     goto MATCH_finished_c; 
44199     
44200   MATCH_label_c392: (void)0; /*placeholder for label*/ 
44201     { 
44202       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44203       nextPC = 3 + MATCH_p; 
44204       
44205 #line 665 "frontend/machine/pentium/decoder.m"
44206       
44207 
44208             stmts = instantiate(pc,  "SARB.Ev.CLow", DIS_EADDR16);
44209 
44210       
44211 
44212       
44213       
44214       
44215     } 
44216     goto MATCH_finished_c; 
44217     
44218   MATCH_label_c393: (void)0; /*placeholder for label*/ 
44219     { 
44220       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44221       nextPC = 4 + MATCH_p; 
44222       
44223 #line 665 "frontend/machine/pentium/decoder.m"
44224       
44225 
44226             stmts = instantiate(pc,  "SARB.Ev.CLow", DIS_EADDR16);
44227 
44228       
44229 
44230       
44231       
44232       
44233     } 
44234     goto MATCH_finished_c; 
44235     
44236   MATCH_label_c394: (void)0; /*placeholder for label*/ 
44237     { 
44238       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44239       nextPC = 8 + MATCH_p; 
44240       
44241 #line 665 "frontend/machine/pentium/decoder.m"
44242       
44243 
44244             stmts = instantiate(pc,  "SARB.Ev.CLow", DIS_EADDR16);
44245 
44246       
44247 
44248       
44249       
44250       
44251     } 
44252     goto MATCH_finished_c; 
44253     
44254   MATCH_label_c395: (void)0; /*placeholder for label*/ 
44255     { 
44256       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44257       nextPC = 7 + MATCH_p; 
44258       
44259 #line 665 "frontend/machine/pentium/decoder.m"
44260       
44261 
44262             stmts = instantiate(pc,  "SARB.Ev.CLow", DIS_EADDR16);
44263 
44264       
44265 
44266       
44267       
44268       
44269     } 
44270     goto MATCH_finished_c; 
44271     
44272   MATCH_label_c396: (void)0; /*placeholder for label*/ 
44273     { 
44274       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44275       unsigned i16 = (MATCH_w_16_24 & 0xffff) /* i16 at 24 */;
44276       nextPC = 5 + MATCH_p; 
44277       
44278 #line 390 "frontend/machine/pentium/decoder.m"
44279       
44280 
44281             stmts = instantiate(pc,  "TEST.Ew.Iw", DIS_EADDR16, DIS_I16);
44282 
44283       
44284 
44285       
44286       
44287       
44288     } 
44289     goto MATCH_finished_c; 
44290     
44291   MATCH_label_c397: (void)0; /*placeholder for label*/ 
44292     { 
44293       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44294       unsigned i16 = (MATCH_w_16_32 & 0xffff) /* i16 at 32 */;
44295       nextPC = 6 + MATCH_p; 
44296       
44297 #line 390 "frontend/machine/pentium/decoder.m"
44298       
44299 
44300             stmts = instantiate(pc,  "TEST.Ew.Iw", DIS_EADDR16, DIS_I16);
44301 
44302       
44303 
44304       
44305       
44306       
44307     } 
44308     goto MATCH_finished_c; 
44309     
44310   MATCH_label_c398: (void)0; /*placeholder for label*/ 
44311     { 
44312       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44313       unsigned i16 = (MATCH_w_16_64 & 0xffff) /* i16 at 64 */;
44314       nextPC = 10 + MATCH_p; 
44315       
44316 #line 390 "frontend/machine/pentium/decoder.m"
44317       
44318 
44319             stmts = instantiate(pc,  "TEST.Ew.Iw", DIS_EADDR16, DIS_I16);
44320 
44321       
44322 
44323       
44324       
44325       
44326     } 
44327     goto MATCH_finished_c; 
44328     
44329   MATCH_label_c399: (void)0; /*placeholder for label*/ 
44330     { 
44331       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44332       unsigned i16 = (MATCH_w_16_56 & 0xffff) /* i16 at 56 */;
44333       nextPC = 9 + MATCH_p; 
44334       
44335 #line 390 "frontend/machine/pentium/decoder.m"
44336       
44337 
44338             stmts = instantiate(pc,  "TEST.Ew.Iw", DIS_EADDR16, DIS_I16);
44339 
44340       
44341 
44342       
44343       
44344       
44345     } 
44346     goto MATCH_finished_c; 
44347     
44348   MATCH_label_c400: (void)0; /*placeholder for label*/ 
44349     { 
44350       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44351       nextPC = 3 + MATCH_p; 
44352       
44353 #line 913 "frontend/machine/pentium/decoder.m"
44354       
44355 
44356             stmts = instantiate(pc,  "NOTow", DIS_EADDR16);
44357 
44358       
44359 
44360       
44361       
44362       
44363     } 
44364     goto MATCH_finished_c; 
44365     
44366   MATCH_label_c401: (void)0; /*placeholder for label*/ 
44367     { 
44368       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44369       nextPC = 4 + MATCH_p; 
44370       
44371 #line 913 "frontend/machine/pentium/decoder.m"
44372       
44373 
44374             stmts = instantiate(pc,  "NOTow", DIS_EADDR16);
44375 
44376       
44377 
44378       
44379       
44380       
44381     } 
44382     goto MATCH_finished_c; 
44383     
44384   MATCH_label_c402: (void)0; /*placeholder for label*/ 
44385     { 
44386       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44387       nextPC = 8 + MATCH_p; 
44388       
44389 #line 913 "frontend/machine/pentium/decoder.m"
44390       
44391 
44392             stmts = instantiate(pc,  "NOTow", DIS_EADDR16);
44393 
44394       
44395 
44396       
44397       
44398       
44399     } 
44400     goto MATCH_finished_c; 
44401     
44402   MATCH_label_c403: (void)0; /*placeholder for label*/ 
44403     { 
44404       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44405       nextPC = 7 + MATCH_p; 
44406       
44407 #line 913 "frontend/machine/pentium/decoder.m"
44408       
44409 
44410             stmts = instantiate(pc,  "NOTow", DIS_EADDR16);
44411 
44412       
44413 
44414       
44415       
44416       
44417     } 
44418     goto MATCH_finished_c; 
44419     
44420   MATCH_label_c404: (void)0; /*placeholder for label*/ 
44421     { 
44422       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44423       nextPC = 3 + MATCH_p; 
44424       
44425 #line 922 "frontend/machine/pentium/decoder.m"
44426       
44427 
44428             stmts = instantiate(pc,  "NEGow", DIS_EADDR16);
44429 
44430       
44431 
44432       
44433       
44434       
44435     } 
44436     goto MATCH_finished_c; 
44437     
44438   MATCH_label_c405: (void)0; /*placeholder for label*/ 
44439     { 
44440       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44441       nextPC = 4 + MATCH_p; 
44442       
44443 #line 922 "frontend/machine/pentium/decoder.m"
44444       
44445 
44446             stmts = instantiate(pc,  "NEGow", DIS_EADDR16);
44447 
44448       
44449 
44450       
44451       
44452       
44453     } 
44454     goto MATCH_finished_c; 
44455     
44456   MATCH_label_c406: (void)0; /*placeholder for label*/ 
44457     { 
44458       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44459       nextPC = 8 + MATCH_p; 
44460       
44461 #line 922 "frontend/machine/pentium/decoder.m"
44462       
44463 
44464             stmts = instantiate(pc,  "NEGow", DIS_EADDR16);
44465 
44466       
44467 
44468       
44469       
44470       
44471     } 
44472     goto MATCH_finished_c; 
44473     
44474   MATCH_label_c407: (void)0; /*placeholder for label*/ 
44475     { 
44476       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44477       nextPC = 7 + MATCH_p; 
44478       
44479 #line 922 "frontend/machine/pentium/decoder.m"
44480       
44481 
44482             stmts = instantiate(pc,  "NEGow", DIS_EADDR16);
44483 
44484       
44485 
44486       
44487       
44488       
44489     } 
44490     goto MATCH_finished_c; 
44491     
44492   MATCH_label_c408: (void)0; /*placeholder for label*/ 
44493     { 
44494       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44495       nextPC = 3 + MATCH_p; 
44496       
44497 #line 931 "frontend/machine/pentium/decoder.m"
44498       
44499 
44500             stmts = instantiate(pc,  "MUL.AXow", DIS_EADDR16);
44501 
44502       
44503 
44504       
44505       
44506       
44507     } 
44508     goto MATCH_finished_c; 
44509     
44510   MATCH_label_c409: (void)0; /*placeholder for label*/ 
44511     { 
44512       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44513       nextPC = 4 + MATCH_p; 
44514       
44515 #line 931 "frontend/machine/pentium/decoder.m"
44516       
44517 
44518             stmts = instantiate(pc,  "MUL.AXow", DIS_EADDR16);
44519 
44520       
44521 
44522       
44523       
44524       
44525     } 
44526     goto MATCH_finished_c; 
44527     
44528   MATCH_label_c410: (void)0; /*placeholder for label*/ 
44529     { 
44530       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44531       nextPC = 8 + MATCH_p; 
44532       
44533 #line 931 "frontend/machine/pentium/decoder.m"
44534       
44535 
44536             stmts = instantiate(pc,  "MUL.AXow", DIS_EADDR16);
44537 
44538       
44539 
44540       
44541       
44542       
44543     } 
44544     goto MATCH_finished_c; 
44545     
44546   MATCH_label_c411: (void)0; /*placeholder for label*/ 
44547     { 
44548       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44549       nextPC = 7 + MATCH_p; 
44550       
44551 #line 931 "frontend/machine/pentium/decoder.m"
44552       
44553 
44554             stmts = instantiate(pc,  "MUL.AXow", DIS_EADDR16);
44555 
44556       
44557 
44558       
44559       
44560       
44561     } 
44562     goto MATCH_finished_c; 
44563     
44564   MATCH_label_c412: (void)0; /*placeholder for label*/ 
44565     { 
44566       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44567       nextPC = 3 + MATCH_p; 
44568       
44569 #line 1175 "frontend/machine/pentium/decoder.m"
44570       
44571 
44572             stmts = instantiate(pc,  "IMULow", DIS_EADDR16);
44573 
44574       
44575 
44576       
44577       
44578       
44579     } 
44580     goto MATCH_finished_c; 
44581     
44582   MATCH_label_c413: (void)0; /*placeholder for label*/ 
44583     { 
44584       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44585       nextPC = 4 + MATCH_p; 
44586       
44587 #line 1175 "frontend/machine/pentium/decoder.m"
44588       
44589 
44590             stmts = instantiate(pc,  "IMULow", DIS_EADDR16);
44591 
44592       
44593 
44594       
44595       
44596       
44597     } 
44598     goto MATCH_finished_c; 
44599     
44600   MATCH_label_c414: (void)0; /*placeholder for label*/ 
44601     { 
44602       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44603       nextPC = 8 + MATCH_p; 
44604       
44605 #line 1175 "frontend/machine/pentium/decoder.m"
44606       
44607 
44608             stmts = instantiate(pc,  "IMULow", DIS_EADDR16);
44609 
44610       
44611 
44612       
44613       
44614       
44615     } 
44616     goto MATCH_finished_c; 
44617     
44618   MATCH_label_c415: (void)0; /*placeholder for label*/ 
44619     { 
44620       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44621       nextPC = 7 + MATCH_p; 
44622       
44623 #line 1175 "frontend/machine/pentium/decoder.m"
44624       
44625 
44626             stmts = instantiate(pc,  "IMULow", DIS_EADDR16);
44627 
44628       
44629 
44630       
44631       
44632       
44633     } 
44634     goto MATCH_finished_c; 
44635     
44636   MATCH_label_c416: (void)0; /*placeholder for label*/ 
44637     { 
44638       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44639       nextPC = 3 + MATCH_p; 
44640       
44641 #line 1199 "frontend/machine/pentium/decoder.m"
44642       
44643 
44644             stmts = instantiate(pc,  "DIVAX", DIS_EADDR16);
44645 
44646       
44647 
44648       
44649       
44650       
44651     } 
44652     goto MATCH_finished_c; 
44653     
44654   MATCH_label_c417: (void)0; /*placeholder for label*/ 
44655     { 
44656       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44657       nextPC = 4 + MATCH_p; 
44658       
44659 #line 1199 "frontend/machine/pentium/decoder.m"
44660       
44661 
44662             stmts = instantiate(pc,  "DIVAX", DIS_EADDR16);
44663 
44664       
44665 
44666       
44667       
44668       
44669     } 
44670     goto MATCH_finished_c; 
44671     
44672   MATCH_label_c418: (void)0; /*placeholder for label*/ 
44673     { 
44674       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44675       nextPC = 8 + MATCH_p; 
44676       
44677 #line 1199 "frontend/machine/pentium/decoder.m"
44678       
44679 
44680             stmts = instantiate(pc,  "DIVAX", DIS_EADDR16);
44681 
44682       
44683 
44684       
44685       
44686       
44687     } 
44688     goto MATCH_finished_c; 
44689     
44690   MATCH_label_c419: (void)0; /*placeholder for label*/ 
44691     { 
44692       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44693       nextPC = 7 + MATCH_p; 
44694       
44695 #line 1199 "frontend/machine/pentium/decoder.m"
44696       
44697 
44698             stmts = instantiate(pc,  "DIVAX", DIS_EADDR16);
44699 
44700       
44701 
44702       
44703       
44704       
44705     } 
44706     goto MATCH_finished_c; 
44707     
44708   MATCH_label_c420: (void)0; /*placeholder for label*/ 
44709     { 
44710       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44711       nextPC = 3 + MATCH_p; 
44712       
44713 #line 1184 "frontend/machine/pentium/decoder.m"
44714       
44715 
44716             stmts = instantiate(pc,  "IDIVAX", DIS_EADDR16);
44717 
44718       
44719 
44720       
44721       
44722       
44723     } 
44724     goto MATCH_finished_c; 
44725     
44726   MATCH_label_c421: (void)0; /*placeholder for label*/ 
44727     { 
44728       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44729       nextPC = 4 + MATCH_p; 
44730       
44731 #line 1184 "frontend/machine/pentium/decoder.m"
44732       
44733 
44734             stmts = instantiate(pc,  "IDIVAX", DIS_EADDR16);
44735 
44736       
44737 
44738       
44739       
44740       
44741     } 
44742     goto MATCH_finished_c; 
44743     
44744   MATCH_label_c422: (void)0; /*placeholder for label*/ 
44745     { 
44746       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44747       nextPC = 8 + MATCH_p; 
44748       
44749 #line 1184 "frontend/machine/pentium/decoder.m"
44750       
44751 
44752             stmts = instantiate(pc,  "IDIVAX", DIS_EADDR16);
44753 
44754       
44755 
44756       
44757       
44758       
44759     } 
44760     goto MATCH_finished_c; 
44761     
44762   MATCH_label_c423: (void)0; /*placeholder for label*/ 
44763     { 
44764       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44765       nextPC = 7 + MATCH_p; 
44766       
44767 #line 1184 "frontend/machine/pentium/decoder.m"
44768       
44769 
44770             stmts = instantiate(pc,  "IDIVAX", DIS_EADDR16);
44771 
44772       
44773 
44774       
44775       
44776       
44777     } 
44778     goto MATCH_finished_c; 
44779     
44780   MATCH_label_c424: (void)0; /*placeholder for label*/ 
44781     { 
44782       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44783       nextPC = 3 + MATCH_p; 
44784       
44785 #line 1130 "frontend/machine/pentium/decoder.m"
44786       
44787 
44788             stmts = instantiate(pc,  "INC.Evow", DIS_EADDR16);
44789 
44790       
44791 
44792       
44793       
44794       
44795     } 
44796     goto MATCH_finished_c; 
44797     
44798   MATCH_label_c425: (void)0; /*placeholder for label*/ 
44799     { 
44800       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44801       nextPC = 4 + MATCH_p; 
44802       
44803 #line 1130 "frontend/machine/pentium/decoder.m"
44804       
44805 
44806             stmts = instantiate(pc,  "INC.Evow", DIS_EADDR16);
44807 
44808       
44809 
44810       
44811       
44812       
44813     } 
44814     goto MATCH_finished_c; 
44815     
44816   MATCH_label_c426: (void)0; /*placeholder for label*/ 
44817     { 
44818       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44819       nextPC = 8 + MATCH_p; 
44820       
44821 #line 1130 "frontend/machine/pentium/decoder.m"
44822       
44823 
44824             stmts = instantiate(pc,  "INC.Evow", DIS_EADDR16);
44825 
44826       
44827 
44828       
44829       
44830       
44831     } 
44832     goto MATCH_finished_c; 
44833     
44834   MATCH_label_c427: (void)0; /*placeholder for label*/ 
44835     { 
44836       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44837       nextPC = 7 + MATCH_p; 
44838       
44839 #line 1130 "frontend/machine/pentium/decoder.m"
44840       
44841 
44842             stmts = instantiate(pc,  "INC.Evow", DIS_EADDR16);
44843 
44844       
44845 
44846       
44847       
44848       
44849     } 
44850     goto MATCH_finished_c; 
44851     
44852   MATCH_label_c428: (void)0; /*placeholder for label*/ 
44853     { 
44854       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44855       nextPC = 3 + MATCH_p; 
44856       
44857 #line 1214 "frontend/machine/pentium/decoder.m"
44858       
44859 
44860             stmts = instantiate(pc,  "DEC.Evow", DIS_EADDR16);
44861 
44862       
44863 
44864       
44865       
44866       
44867     } 
44868     goto MATCH_finished_c; 
44869     
44870   MATCH_label_c429: (void)0; /*placeholder for label*/ 
44871     { 
44872       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44873       nextPC = 4 + MATCH_p; 
44874       
44875 #line 1214 "frontend/machine/pentium/decoder.m"
44876       
44877 
44878             stmts = instantiate(pc,  "DEC.Evow", DIS_EADDR16);
44879 
44880       
44881 
44882       
44883       
44884       
44885     } 
44886     goto MATCH_finished_c; 
44887     
44888   MATCH_label_c430: (void)0; /*placeholder for label*/ 
44889     { 
44890       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44891       nextPC = 8 + MATCH_p; 
44892       
44893 #line 1214 "frontend/machine/pentium/decoder.m"
44894       
44895 
44896             stmts = instantiate(pc,  "DEC.Evow", DIS_EADDR16);
44897 
44898       
44899 
44900       
44901       
44902       
44903     } 
44904     goto MATCH_finished_c; 
44905     
44906   MATCH_label_c431: (void)0; /*placeholder for label*/ 
44907     { 
44908       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44909       nextPC = 7 + MATCH_p; 
44910       
44911 #line 1214 "frontend/machine/pentium/decoder.m"
44912       
44913 
44914             stmts = instantiate(pc,  "DEC.Evow", DIS_EADDR16);
44915 
44916       
44917 
44918       
44919       
44920       
44921     } 
44922     goto MATCH_finished_c; 
44923     
44924   MATCH_label_c432: (void)0; /*placeholder for label*/ 
44925     { 
44926       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44927       nextPC = 3 + MATCH_p; 
44928       
44929 #line 841 "frontend/machine/pentium/decoder.m"
44930       
44931 
44932             stmts = instantiate(pc,  "PUSH.Evow", DIS_EADDR16);
44933 
44934       
44935 
44936       //      | POPFod() =>
44937 
44938       //          stmts = instantiate(pc,  "POPFod");
44939 
44940       
44941 
44942       //      | POPFow() =>
44943 
44944       //          stmts = instantiate(pc,  "POPFow");
44945 
44946       
44947 
44948       //      | POPAod() =>
44949 
44950       //          stmts = instantiate(pc,  "POPAod");
44951 
44952       
44953 
44954       //      | POPAow() =>
44955 
44956       //          stmts = instantiate(pc,  "POPAow");
44957 
44958       
44959 
44960       
44961       
44962       
44963     } 
44964     goto MATCH_finished_c; 
44965     
44966   MATCH_label_c433: (void)0; /*placeholder for label*/ 
44967     { 
44968       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44969       nextPC = 4 + MATCH_p; 
44970       
44971 #line 841 "frontend/machine/pentium/decoder.m"
44972       
44973 
44974             stmts = instantiate(pc,  "PUSH.Evow", DIS_EADDR16);
44975 
44976       
44977 
44978       //      | POPFod() =>
44979 
44980       //          stmts = instantiate(pc,  "POPFod");
44981 
44982       
44983 
44984       //      | POPFow() =>
44985 
44986       //          stmts = instantiate(pc,  "POPFow");
44987 
44988       
44989 
44990       //      | POPAod() =>
44991 
44992       //          stmts = instantiate(pc,  "POPAod");
44993 
44994       
44995 
44996       //      | POPAow() =>
44997 
44998       //          stmts = instantiate(pc,  "POPAow");
44999 
45000       
45001 
45002       
45003       
45004       
45005     } 
45006     goto MATCH_finished_c; 
45007     
45008   MATCH_label_c434: (void)0; /*placeholder for label*/ 
45009     { 
45010       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45011       nextPC = 8 + MATCH_p; 
45012       
45013 #line 841 "frontend/machine/pentium/decoder.m"
45014       
45015 
45016             stmts = instantiate(pc,  "PUSH.Evow", DIS_EADDR16);
45017 
45018       
45019 
45020       //      | POPFod() =>
45021 
45022       //          stmts = instantiate(pc,  "POPFod");
45023 
45024       
45025 
45026       //      | POPFow() =>
45027 
45028       //          stmts = instantiate(pc,  "POPFow");
45029 
45030       
45031 
45032       //      | POPAod() =>
45033 
45034       //          stmts = instantiate(pc,  "POPAod");
45035 
45036       
45037 
45038       //      | POPAow() =>
45039 
45040       //          stmts = instantiate(pc,  "POPAow");
45041 
45042       
45043 
45044       
45045       
45046       
45047     } 
45048     goto MATCH_finished_c; 
45049     
45050   MATCH_label_c435: (void)0; /*placeholder for label*/ 
45051     { 
45052       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45053       nextPC = 7 + MATCH_p; 
45054       
45055 #line 841 "frontend/machine/pentium/decoder.m"
45056       
45057 
45058             stmts = instantiate(pc,  "PUSH.Evow", DIS_EADDR16);
45059 
45060       
45061 
45062       //      | POPFod() =>
45063 
45064       //          stmts = instantiate(pc,  "POPFod");
45065 
45066       
45067 
45068       //      | POPFow() =>
45069 
45070       //          stmts = instantiate(pc,  "POPFow");
45071 
45072       
45073 
45074       //      | POPAod() =>
45075 
45076       //          stmts = instantiate(pc,  "POPAod");
45077 
45078       
45079 
45080       //      | POPAow() =>
45081 
45082       //          stmts = instantiate(pc,  "POPAow");
45083 
45084       
45085 
45086       
45087       
45088       
45089     } 
45090     goto MATCH_finished_c; 
45091     
45092   MATCH_label_c436: (void)0; /*placeholder for label*/ 
45093     { 
45094       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45095       int /* [~128..127] */ i8 = 
45096         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
45097       nextPC = 3 + MATCH_p; 
45098       
45099 #line 1669 "frontend/machine/pentium/decoder.m"
45100       
45101 
45102             stmts = instantiate(pc,  "ADDib", DIS_EADDR8, DIS_I8);
45103 
45104       
45105 
45106       
45107       
45108       
45109     } 
45110     goto MATCH_finished_c; 
45111     
45112   MATCH_label_c437: (void)0; /*placeholder for label*/ 
45113     { 
45114       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45115       int /* [~128..127] */ i8 = 
45116         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
45117       nextPC = 4 + MATCH_p; 
45118       
45119 #line 1669 "frontend/machine/pentium/decoder.m"
45120       
45121 
45122             stmts = instantiate(pc,  "ADDib", DIS_EADDR8, DIS_I8);
45123 
45124       
45125 
45126       
45127       
45128       
45129     } 
45130     goto MATCH_finished_c; 
45131     
45132   MATCH_label_c438: (void)0; /*placeholder for label*/ 
45133     { 
45134       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45135       int /* [~128..127] */ i8 = 
45136         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
45137       nextPC = 8 + MATCH_p; 
45138       
45139 #line 1669 "frontend/machine/pentium/decoder.m"
45140       
45141 
45142             stmts = instantiate(pc,  "ADDib", DIS_EADDR8, DIS_I8);
45143 
45144       
45145 
45146       
45147       
45148       
45149     } 
45150     goto MATCH_finished_c; 
45151     
45152   MATCH_label_c439: (void)0; /*placeholder for label*/ 
45153     { 
45154       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45155       int /* [~128..127] */ i8 = 
45156         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
45157       nextPC = 7 + MATCH_p; 
45158       
45159 #line 1669 "frontend/machine/pentium/decoder.m"
45160       
45161 
45162             stmts = instantiate(pc,  "ADDib", DIS_EADDR8, DIS_I8);
45163 
45164       
45165 
45166       
45167       
45168       
45169     } 
45170     goto MATCH_finished_c; 
45171     
45172   MATCH_label_c440: (void)0; /*placeholder for label*/ 
45173     { 
45174       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45175       int /* [~128..127] */ i8 = 
45176         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
45177       nextPC = 3 + MATCH_p; 
45178       
45179 #line 1666 "frontend/machine/pentium/decoder.m"
45180       
45181 
45182             stmts = instantiate(pc,  "ORib", DIS_EADDR8, DIS_I8);
45183 
45184       
45185 
45186       
45187       
45188       
45189     } 
45190     goto MATCH_finished_c; 
45191     
45192   MATCH_label_c441: (void)0; /*placeholder for label*/ 
45193     { 
45194       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45195       int /* [~128..127] */ i8 = 
45196         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
45197       nextPC = 4 + MATCH_p; 
45198       
45199 #line 1666 "frontend/machine/pentium/decoder.m"
45200       
45201 
45202             stmts = instantiate(pc,  "ORib", DIS_EADDR8, DIS_I8);
45203 
45204       
45205 
45206       
45207       
45208       
45209     } 
45210     goto MATCH_finished_c; 
45211     
45212   MATCH_label_c442: (void)0; /*placeholder for label*/ 
45213     { 
45214       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45215       int /* [~128..127] */ i8 = 
45216         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
45217       nextPC = 8 + MATCH_p; 
45218       
45219 #line 1666 "frontend/machine/pentium/decoder.m"
45220       
45221 
45222             stmts = instantiate(pc,  "ORib", DIS_EADDR8, DIS_I8);
45223 
45224       
45225 
45226       
45227       
45228       
45229     } 
45230     goto MATCH_finished_c; 
45231     
45232   MATCH_label_c443: (void)0; /*placeholder for label*/ 
45233     { 
45234       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45235       int /* [~128..127] */ i8 = 
45236         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
45237       nextPC = 7 + MATCH_p; 
45238       
45239 #line 1666 "frontend/machine/pentium/decoder.m"
45240       
45241 
45242             stmts = instantiate(pc,  "ORib", DIS_EADDR8, DIS_I8);
45243 
45244       
45245 
45246       
45247       
45248       
45249     } 
45250     goto MATCH_finished_c; 
45251     
45252   MATCH_label_c444: (void)0; /*placeholder for label*/ 
45253     { 
45254       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45255       int /* [~128..127] */ i8 = 
45256         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
45257       nextPC = 3 + MATCH_p; 
45258       
45259 #line 1663 "frontend/machine/pentium/decoder.m"
45260       
45261 
45262             stmts = instantiate(pc,  "ADCib", DIS_EADDR8, DIS_I8);
45263 
45264       
45265 
45266       
45267       
45268       
45269     } 
45270     goto MATCH_finished_c; 
45271     
45272   MATCH_label_c445: (void)0; /*placeholder for label*/ 
45273     { 
45274       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45275       int /* [~128..127] */ i8 = 
45276         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
45277       nextPC = 4 + MATCH_p; 
45278       
45279 #line 1663 "frontend/machine/pentium/decoder.m"
45280       
45281 
45282             stmts = instantiate(pc,  "ADCib", DIS_EADDR8, DIS_I8);
45283 
45284       
45285 
45286       
45287       
45288       
45289     } 
45290     goto MATCH_finished_c; 
45291     
45292   MATCH_label_c446: (void)0; /*placeholder for label*/ 
45293     { 
45294       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45295       int /* [~128..127] */ i8 = 
45296         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
45297       nextPC = 8 + MATCH_p; 
45298       
45299 #line 1663 "frontend/machine/pentium/decoder.m"
45300       
45301 
45302             stmts = instantiate(pc,  "ADCib", DIS_EADDR8, DIS_I8);
45303 
45304       
45305 
45306       
45307       
45308       
45309     } 
45310     goto MATCH_finished_c; 
45311     
45312   MATCH_label_c447: (void)0; /*placeholder for label*/ 
45313     { 
45314       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45315       int /* [~128..127] */ i8 = 
45316         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
45317       nextPC = 7 + MATCH_p; 
45318       
45319 #line 1663 "frontend/machine/pentium/decoder.m"
45320       
45321 
45322             stmts = instantiate(pc,  "ADCib", DIS_EADDR8, DIS_I8);
45323 
45324       
45325 
45326       
45327       
45328       
45329     } 
45330     goto MATCH_finished_c; 
45331     
45332   MATCH_label_c448: (void)0; /*placeholder for label*/ 
45333     { 
45334       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45335       int /* [~128..127] */ i8 = 
45336         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
45337       nextPC = 3 + MATCH_p; 
45338       
45339 #line 1660 "frontend/machine/pentium/decoder.m"
45340       
45341 
45342             stmts = instantiate(pc,  "SBBib", DIS_EADDR8, DIS_I8);
45343 
45344       
45345 
45346       
45347       
45348       
45349     } 
45350     goto MATCH_finished_c; 
45351     
45352   MATCH_label_c449: (void)0; /*placeholder for label*/ 
45353     { 
45354       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45355       int /* [~128..127] */ i8 = 
45356         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
45357       nextPC = 4 + MATCH_p; 
45358       
45359 #line 1660 "frontend/machine/pentium/decoder.m"
45360       
45361 
45362             stmts = instantiate(pc,  "SBBib", DIS_EADDR8, DIS_I8);
45363 
45364       
45365 
45366       
45367       
45368       
45369     } 
45370     goto MATCH_finished_c; 
45371     
45372   MATCH_label_c450: (void)0; /*placeholder for label*/ 
45373     { 
45374       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45375       int /* [~128..127] */ i8 = 
45376         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
45377       nextPC = 8 + MATCH_p; 
45378       
45379 #line 1660 "frontend/machine/pentium/decoder.m"
45380       
45381 
45382             stmts = instantiate(pc,  "SBBib", DIS_EADDR8, DIS_I8);
45383 
45384       
45385 
45386       
45387       
45388       
45389     } 
45390     goto MATCH_finished_c; 
45391     
45392   MATCH_label_c451: (void)0; /*placeholder for label*/ 
45393     { 
45394       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45395       int /* [~128..127] */ i8 = 
45396         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
45397       nextPC = 7 + MATCH_p; 
45398       
45399 #line 1660 "frontend/machine/pentium/decoder.m"
45400       
45401 
45402             stmts = instantiate(pc,  "SBBib", DIS_EADDR8, DIS_I8);
45403 
45404       
45405 
45406       
45407       
45408       
45409     } 
45410     goto MATCH_finished_c; 
45411     
45412   MATCH_label_c452: (void)0; /*placeholder for label*/ 
45413     { 
45414       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45415       int /* [~128..127] */ i8 = 
45416         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
45417       nextPC = 3 + MATCH_p; 
45418       
45419 #line 1657 "frontend/machine/pentium/decoder.m"
45420       
45421 
45422             stmts = instantiate(pc,  "ANDib", DIS_EADDR8, DIS_I8);
45423 
45424       
45425 
45426       
45427       
45428       
45429     } 
45430     goto MATCH_finished_c; 
45431     
45432   MATCH_label_c453: (void)0; /*placeholder for label*/ 
45433     { 
45434       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45435       int /* [~128..127] */ i8 = 
45436         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
45437       nextPC = 4 + MATCH_p; 
45438       
45439 #line 1657 "frontend/machine/pentium/decoder.m"
45440       
45441 
45442             stmts = instantiate(pc,  "ANDib", DIS_EADDR8, DIS_I8);
45443 
45444       
45445 
45446       
45447       
45448       
45449     } 
45450     goto MATCH_finished_c; 
45451     
45452   MATCH_label_c454: (void)0; /*placeholder for label*/ 
45453     { 
45454       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45455       int /* [~128..127] */ i8 = 
45456         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
45457       nextPC = 8 + MATCH_p; 
45458       
45459 #line 1657 "frontend/machine/pentium/decoder.m"
45460       
45461 
45462             stmts = instantiate(pc,  "ANDib", DIS_EADDR8, DIS_I8);
45463 
45464       
45465 
45466       
45467       
45468       
45469     } 
45470     goto MATCH_finished_c; 
45471     
45472   MATCH_label_c455: (void)0; /*placeholder for label*/ 
45473     { 
45474       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45475       int /* [~128..127] */ i8 = 
45476         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
45477       nextPC = 7 + MATCH_p; 
45478       
45479 #line 1657 "frontend/machine/pentium/decoder.m"
45480       
45481 
45482             stmts = instantiate(pc,  "ANDib", DIS_EADDR8, DIS_I8);
45483 
45484       
45485 
45486       
45487       
45488       
45489     } 
45490     goto MATCH_finished_c; 
45491     
45492   MATCH_label_c456: (void)0; /*placeholder for label*/ 
45493     { 
45494       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45495       int /* [~128..127] */ i8 = 
45496         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
45497       nextPC = 3 + MATCH_p; 
45498       
45499 #line 1654 "frontend/machine/pentium/decoder.m"
45500       
45501 
45502             stmts = instantiate(pc,  "SUBib", DIS_EADDR8, DIS_I8);
45503 
45504       
45505 
45506       
45507       
45508       
45509     } 
45510     goto MATCH_finished_c; 
45511     
45512   MATCH_label_c457: (void)0; /*placeholder for label*/ 
45513     { 
45514       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45515       int /* [~128..127] */ i8 = 
45516         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
45517       nextPC = 4 + MATCH_p; 
45518       
45519 #line 1654 "frontend/machine/pentium/decoder.m"
45520       
45521 
45522             stmts = instantiate(pc,  "SUBib", DIS_EADDR8, DIS_I8);
45523 
45524       
45525 
45526       
45527       
45528       
45529     } 
45530     goto MATCH_finished_c; 
45531     
45532   MATCH_label_c458: (void)0; /*placeholder for label*/ 
45533     { 
45534       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45535       int /* [~128..127] */ i8 = 
45536         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
45537       nextPC = 8 + MATCH_p; 
45538       
45539 #line 1654 "frontend/machine/pentium/decoder.m"
45540       
45541 
45542             stmts = instantiate(pc,  "SUBib", DIS_EADDR8, DIS_I8);
45543 
45544       
45545 
45546       
45547       
45548       
45549     } 
45550     goto MATCH_finished_c; 
45551     
45552   MATCH_label_c459: (void)0; /*placeholder for label*/ 
45553     { 
45554       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45555       int /* [~128..127] */ i8 = 
45556         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
45557       nextPC = 7 + MATCH_p; 
45558       
45559 #line 1654 "frontend/machine/pentium/decoder.m"
45560       
45561 
45562             stmts = instantiate(pc,  "SUBib", DIS_EADDR8, DIS_I8);
45563 
45564       
45565 
45566       
45567       
45568       
45569     } 
45570     goto MATCH_finished_c; 
45571     
45572   MATCH_label_c460: (void)0; /*placeholder for label*/ 
45573     { 
45574       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45575       int /* [~128..127] */ i8 = 
45576         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
45577       nextPC = 3 + MATCH_p; 
45578       
45579 #line 1651 "frontend/machine/pentium/decoder.m"
45580       
45581 
45582             stmts = instantiate(pc,  "XORib", DIS_EADDR8, DIS_I8);
45583 
45584       
45585 
45586       
45587       
45588       
45589     } 
45590     goto MATCH_finished_c; 
45591     
45592   MATCH_label_c461: (void)0; /*placeholder for label*/ 
45593     { 
45594       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45595       int /* [~128..127] */ i8 = 
45596         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
45597       nextPC = 4 + MATCH_p; 
45598       
45599 #line 1651 "frontend/machine/pentium/decoder.m"
45600       
45601 
45602             stmts = instantiate(pc,  "XORib", DIS_EADDR8, DIS_I8);
45603 
45604       
45605 
45606       
45607       
45608       
45609     } 
45610     goto MATCH_finished_c; 
45611     
45612   MATCH_label_c462: (void)0; /*placeholder for label*/ 
45613     { 
45614       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45615       int /* [~128..127] */ i8 = 
45616         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
45617       nextPC = 8 + MATCH_p; 
45618       
45619 #line 1651 "frontend/machine/pentium/decoder.m"
45620       
45621 
45622             stmts = instantiate(pc,  "XORib", DIS_EADDR8, DIS_I8);
45623 
45624       
45625 
45626       
45627       
45628       
45629     } 
45630     goto MATCH_finished_c; 
45631     
45632   MATCH_label_c463: (void)0; /*placeholder for label*/ 
45633     { 
45634       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45635       int /* [~128..127] */ i8 = 
45636         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
45637       nextPC = 7 + MATCH_p; 
45638       
45639 #line 1651 "frontend/machine/pentium/decoder.m"
45640       
45641 
45642             stmts = instantiate(pc,  "XORib", DIS_EADDR8, DIS_I8);
45643 
45644       
45645 
45646       
45647       
45648       
45649     } 
45650     goto MATCH_finished_c; 
45651     
45652   MATCH_label_c464: (void)0; /*placeholder for label*/ 
45653     { 
45654       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45655       int /* [~128..127] */ i8 = 
45656         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
45657       nextPC = 3 + MATCH_p; 
45658       
45659 #line 1648 "frontend/machine/pentium/decoder.m"
45660       
45661 
45662             stmts = instantiate(pc,  "CMPib", DIS_EADDR8, DIS_I8);
45663 
45664       
45665 
45666       
45667       
45668       
45669     } 
45670     goto MATCH_finished_c; 
45671     
45672   MATCH_label_c465: (void)0; /*placeholder for label*/ 
45673     { 
45674       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45675       int /* [~128..127] */ i8 = 
45676         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
45677       nextPC = 4 + MATCH_p; 
45678       
45679 #line 1648 "frontend/machine/pentium/decoder.m"
45680       
45681 
45682             stmts = instantiate(pc,  "CMPib", DIS_EADDR8, DIS_I8);
45683 
45684       
45685 
45686       
45687       
45688       
45689     } 
45690     goto MATCH_finished_c; 
45691     
45692   MATCH_label_c466: (void)0; /*placeholder for label*/ 
45693     { 
45694       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45695       int /* [~128..127] */ i8 = 
45696         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
45697       nextPC = 8 + MATCH_p; 
45698       
45699 #line 1648 "frontend/machine/pentium/decoder.m"
45700       
45701 
45702             stmts = instantiate(pc,  "CMPib", DIS_EADDR8, DIS_I8);
45703 
45704       
45705 
45706       
45707       
45708       
45709     } 
45710     goto MATCH_finished_c; 
45711     
45712   MATCH_label_c467: (void)0; /*placeholder for label*/ 
45713     { 
45714       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45715       int /* [~128..127] */ i8 = 
45716         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
45717       nextPC = 7 + MATCH_p; 
45718       
45719 #line 1648 "frontend/machine/pentium/decoder.m"
45720       
45721 
45722             stmts = instantiate(pc,  "CMPib", DIS_EADDR8, DIS_I8);
45723 
45724       
45725 
45726       
45727       
45728       
45729     } 
45730     goto MATCH_finished_c; 
45731     
45732   MATCH_label_c468: (void)0; /*placeholder for label*/ 
45733     { 
45734       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45735       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
45736       nextPC = 6 + MATCH_p; 
45737       
45738 #line 1621 "frontend/machine/pentium/decoder.m"
45739       
45740 
45741             stmts = instantiate(pc,  "ADDid", DIS_EADDR32, DIS_I32);
45742 
45743       
45744 
45745       
45746       
45747       
45748     } 
45749     goto MATCH_finished_c; 
45750     
45751   MATCH_label_c469: (void)0; /*placeholder for label*/ 
45752     { 
45753       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45754       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
45755       nextPC = 7 + MATCH_p; 
45756       
45757 #line 1621 "frontend/machine/pentium/decoder.m"
45758       
45759 
45760             stmts = instantiate(pc,  "ADDid", DIS_EADDR32, DIS_I32);
45761 
45762       
45763 
45764       
45765       
45766       
45767     } 
45768     goto MATCH_finished_c; 
45769     
45770   MATCH_label_c470: (void)0; /*placeholder for label*/ 
45771     { 
45772       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45773       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
45774       nextPC = 11 + MATCH_p; 
45775       
45776 #line 1621 "frontend/machine/pentium/decoder.m"
45777       
45778 
45779             stmts = instantiate(pc,  "ADDid", DIS_EADDR32, DIS_I32);
45780 
45781       
45782 
45783       
45784       
45785       
45786     } 
45787     goto MATCH_finished_c; 
45788     
45789   MATCH_label_c471: (void)0; /*placeholder for label*/ 
45790     { 
45791       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45792       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
45793       nextPC = 10 + MATCH_p; 
45794       
45795 #line 1621 "frontend/machine/pentium/decoder.m"
45796       
45797 
45798             stmts = instantiate(pc,  "ADDid", DIS_EADDR32, DIS_I32);
45799 
45800       
45801 
45802       
45803       
45804       
45805     } 
45806     goto MATCH_finished_c; 
45807     
45808   MATCH_label_c472: (void)0; /*placeholder for label*/ 
45809     { 
45810       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45811       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
45812       nextPC = 6 + MATCH_p; 
45813       
45814 #line 1618 "frontend/machine/pentium/decoder.m"
45815       
45816 
45817             stmts = instantiate(pc,  "ORid", DIS_EADDR32, DIS_I32);
45818 
45819       
45820 
45821       
45822       
45823       
45824     } 
45825     goto MATCH_finished_c; 
45826     
45827   MATCH_label_c473: (void)0; /*placeholder for label*/ 
45828     { 
45829       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45830       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
45831       nextPC = 7 + MATCH_p; 
45832       
45833 #line 1618 "frontend/machine/pentium/decoder.m"
45834       
45835 
45836             stmts = instantiate(pc,  "ORid", DIS_EADDR32, DIS_I32);
45837 
45838       
45839 
45840       
45841       
45842       
45843     } 
45844     goto MATCH_finished_c; 
45845     
45846   MATCH_label_c474: (void)0; /*placeholder for label*/ 
45847     { 
45848       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45849       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
45850       nextPC = 11 + MATCH_p; 
45851       
45852 #line 1618 "frontend/machine/pentium/decoder.m"
45853       
45854 
45855             stmts = instantiate(pc,  "ORid", DIS_EADDR32, DIS_I32);
45856 
45857       
45858 
45859       
45860       
45861       
45862     } 
45863     goto MATCH_finished_c; 
45864     
45865   MATCH_label_c475: (void)0; /*placeholder for label*/ 
45866     { 
45867       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45868       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
45869       nextPC = 10 + MATCH_p; 
45870       
45871 #line 1618 "frontend/machine/pentium/decoder.m"
45872       
45873 
45874             stmts = instantiate(pc,  "ORid", DIS_EADDR32, DIS_I32);
45875 
45876       
45877 
45878       
45879       
45880       
45881     } 
45882     goto MATCH_finished_c; 
45883     
45884   MATCH_label_c476: (void)0; /*placeholder for label*/ 
45885     { 
45886       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45887       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
45888       nextPC = 6 + MATCH_p; 
45889       
45890 #line 1615 "frontend/machine/pentium/decoder.m"
45891       
45892 
45893             stmts = instantiate(pc,  "ADCid", DIS_EADDR32, DIS_I32);
45894 
45895       
45896 
45897       
45898       
45899       
45900     } 
45901     goto MATCH_finished_c; 
45902     
45903   MATCH_label_c477: (void)0; /*placeholder for label*/ 
45904     { 
45905       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45906       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
45907       nextPC = 7 + MATCH_p; 
45908       
45909 #line 1615 "frontend/machine/pentium/decoder.m"
45910       
45911 
45912             stmts = instantiate(pc,  "ADCid", DIS_EADDR32, DIS_I32);
45913 
45914       
45915 
45916       
45917       
45918       
45919     } 
45920     goto MATCH_finished_c; 
45921     
45922   MATCH_label_c478: (void)0; /*placeholder for label*/ 
45923     { 
45924       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45925       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
45926       nextPC = 11 + MATCH_p; 
45927       
45928 #line 1615 "frontend/machine/pentium/decoder.m"
45929       
45930 
45931             stmts = instantiate(pc,  "ADCid", DIS_EADDR32, DIS_I32);
45932 
45933       
45934 
45935       
45936       
45937       
45938     } 
45939     goto MATCH_finished_c; 
45940     
45941   MATCH_label_c479: (void)0; /*placeholder for label*/ 
45942     { 
45943       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45944       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
45945       nextPC = 10 + MATCH_p; 
45946       
45947 #line 1615 "frontend/machine/pentium/decoder.m"
45948       
45949 
45950             stmts = instantiate(pc,  "ADCid", DIS_EADDR32, DIS_I32);
45951 
45952       
45953 
45954       
45955       
45956       
45957     } 
45958     goto MATCH_finished_c; 
45959     
45960   MATCH_label_c480: (void)0; /*placeholder for label*/ 
45961     { 
45962       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45963       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
45964       nextPC = 6 + MATCH_p; 
45965       
45966 #line 1612 "frontend/machine/pentium/decoder.m"
45967       
45968 
45969             stmts = instantiate(pc,  "SBBid", DIS_EADDR32, DIS_I32);
45970 
45971       
45972 
45973       
45974       
45975       
45976     } 
45977     goto MATCH_finished_c; 
45978     
45979   MATCH_label_c481: (void)0; /*placeholder for label*/ 
45980     { 
45981       unsigned Eaddr = 1 + addressToPC(MATCH_p);
45982       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
45983       nextPC = 7 + MATCH_p; 
45984       
45985 #line 1612 "frontend/machine/pentium/decoder.m"
45986       
45987 
45988             stmts = instantiate(pc,  "SBBid", DIS_EADDR32, DIS_I32);
45989 
45990       
45991 
45992       
45993       
45994       
45995     } 
45996     goto MATCH_finished_c; 
45997     
45998   MATCH_label_c482: (void)0; /*placeholder for label*/ 
45999     { 
46000       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46001       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
46002       nextPC = 11 + MATCH_p; 
46003       
46004 #line 1612 "frontend/machine/pentium/decoder.m"
46005       
46006 
46007             stmts = instantiate(pc,  "SBBid", DIS_EADDR32, DIS_I32);
46008 
46009       
46010 
46011       
46012       
46013       
46014     } 
46015     goto MATCH_finished_c; 
46016     
46017   MATCH_label_c483: (void)0; /*placeholder for label*/ 
46018     { 
46019       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46020       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
46021       nextPC = 10 + MATCH_p; 
46022       
46023 #line 1612 "frontend/machine/pentium/decoder.m"
46024       
46025 
46026             stmts = instantiate(pc,  "SBBid", DIS_EADDR32, DIS_I32);
46027 
46028       
46029 
46030       
46031       
46032       
46033     } 
46034     goto MATCH_finished_c; 
46035     
46036   MATCH_label_c484: (void)0; /*placeholder for label*/ 
46037     { 
46038       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46039       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
46040       nextPC = 6 + MATCH_p; 
46041       
46042 #line 1609 "frontend/machine/pentium/decoder.m"
46043       
46044 
46045             stmts = instantiate(pc,  "ANDid", DIS_EADDR32, DIS_I32);
46046 
46047       
46048 
46049       
46050       
46051       
46052     } 
46053     goto MATCH_finished_c; 
46054     
46055   MATCH_label_c485: (void)0; /*placeholder for label*/ 
46056     { 
46057       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46058       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
46059       nextPC = 7 + MATCH_p; 
46060       
46061 #line 1609 "frontend/machine/pentium/decoder.m"
46062       
46063 
46064             stmts = instantiate(pc,  "ANDid", DIS_EADDR32, DIS_I32);
46065 
46066       
46067 
46068       
46069       
46070       
46071     } 
46072     goto MATCH_finished_c; 
46073     
46074   MATCH_label_c486: (void)0; /*placeholder for label*/ 
46075     { 
46076       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46077       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
46078       nextPC = 11 + MATCH_p; 
46079       
46080 #line 1609 "frontend/machine/pentium/decoder.m"
46081       
46082 
46083             stmts = instantiate(pc,  "ANDid", DIS_EADDR32, DIS_I32);
46084 
46085       
46086 
46087       
46088       
46089       
46090     } 
46091     goto MATCH_finished_c; 
46092     
46093   MATCH_label_c487: (void)0; /*placeholder for label*/ 
46094     { 
46095       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46096       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
46097       nextPC = 10 + MATCH_p; 
46098       
46099 #line 1609 "frontend/machine/pentium/decoder.m"
46100       
46101 
46102             stmts = instantiate(pc,  "ANDid", DIS_EADDR32, DIS_I32);
46103 
46104       
46105 
46106       
46107       
46108       
46109     } 
46110     goto MATCH_finished_c; 
46111     
46112   MATCH_label_c488: (void)0; /*placeholder for label*/ 
46113     { 
46114       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46115       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
46116       nextPC = 6 + MATCH_p; 
46117       
46118 #line 1606 "frontend/machine/pentium/decoder.m"
46119       
46120 
46121             stmts = instantiate(pc,  "SUBid", DIS_EADDR32, DIS_I32);
46122 
46123       
46124 
46125       
46126       
46127       
46128     } 
46129     goto MATCH_finished_c; 
46130     
46131   MATCH_label_c489: (void)0; /*placeholder for label*/ 
46132     { 
46133       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46134       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
46135       nextPC = 7 + MATCH_p; 
46136       
46137 #line 1606 "frontend/machine/pentium/decoder.m"
46138       
46139 
46140             stmts = instantiate(pc,  "SUBid", DIS_EADDR32, DIS_I32);
46141 
46142       
46143 
46144       
46145       
46146       
46147     } 
46148     goto MATCH_finished_c; 
46149     
46150   MATCH_label_c490: (void)0; /*placeholder for label*/ 
46151     { 
46152       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46153       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
46154       nextPC = 11 + MATCH_p; 
46155       
46156 #line 1606 "frontend/machine/pentium/decoder.m"
46157       
46158 
46159             stmts = instantiate(pc,  "SUBid", DIS_EADDR32, DIS_I32);
46160 
46161       
46162 
46163       
46164       
46165       
46166     } 
46167     goto MATCH_finished_c; 
46168     
46169   MATCH_label_c491: (void)0; /*placeholder for label*/ 
46170     { 
46171       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46172       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
46173       nextPC = 10 + MATCH_p; 
46174       
46175 #line 1606 "frontend/machine/pentium/decoder.m"
46176       
46177 
46178             stmts = instantiate(pc,  "SUBid", DIS_EADDR32, DIS_I32);
46179 
46180       
46181 
46182       
46183       
46184       
46185     } 
46186     goto MATCH_finished_c; 
46187     
46188   MATCH_label_c492: (void)0; /*placeholder for label*/ 
46189     { 
46190       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46191       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
46192       nextPC = 6 + MATCH_p; 
46193       
46194 #line 1603 "frontend/machine/pentium/decoder.m"
46195       
46196 
46197             stmts = instantiate(pc,  "XORid", DIS_EADDR32, DIS_I32);
46198 
46199       
46200 
46201       
46202       
46203       
46204     } 
46205     goto MATCH_finished_c; 
46206     
46207   MATCH_label_c493: (void)0; /*placeholder for label*/ 
46208     { 
46209       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46210       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
46211       nextPC = 7 + MATCH_p; 
46212       
46213 #line 1603 "frontend/machine/pentium/decoder.m"
46214       
46215 
46216             stmts = instantiate(pc,  "XORid", DIS_EADDR32, DIS_I32);
46217 
46218       
46219 
46220       
46221       
46222       
46223     } 
46224     goto MATCH_finished_c; 
46225     
46226   MATCH_label_c494: (void)0; /*placeholder for label*/ 
46227     { 
46228       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46229       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
46230       nextPC = 11 + MATCH_p; 
46231       
46232 #line 1603 "frontend/machine/pentium/decoder.m"
46233       
46234 
46235             stmts = instantiate(pc,  "XORid", DIS_EADDR32, DIS_I32);
46236 
46237       
46238 
46239       
46240       
46241       
46242     } 
46243     goto MATCH_finished_c; 
46244     
46245   MATCH_label_c495: (void)0; /*placeholder for label*/ 
46246     { 
46247       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46248       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
46249       nextPC = 10 + MATCH_p; 
46250       
46251 #line 1603 "frontend/machine/pentium/decoder.m"
46252       
46253 
46254             stmts = instantiate(pc,  "XORid", DIS_EADDR32, DIS_I32);
46255 
46256       
46257 
46258       
46259       
46260       
46261     } 
46262     goto MATCH_finished_c; 
46263     
46264   MATCH_label_c496: (void)0; /*placeholder for label*/ 
46265     { 
46266       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46267       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
46268       nextPC = 6 + MATCH_p; 
46269       
46270 #line 1600 "frontend/machine/pentium/decoder.m"
46271       
46272 
46273             stmts = instantiate(pc,  "CMPid", DIS_EADDR32, DIS_I32);
46274 
46275       
46276 
46277       
46278       
46279       
46280     } 
46281     goto MATCH_finished_c; 
46282     
46283   MATCH_label_c497: (void)0; /*placeholder for label*/ 
46284     { 
46285       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46286       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
46287       nextPC = 7 + MATCH_p; 
46288       
46289 #line 1600 "frontend/machine/pentium/decoder.m"
46290       
46291 
46292             stmts = instantiate(pc,  "CMPid", DIS_EADDR32, DIS_I32);
46293 
46294       
46295 
46296       
46297       
46298       
46299     } 
46300     goto MATCH_finished_c; 
46301     
46302   MATCH_label_c498: (void)0; /*placeholder for label*/ 
46303     { 
46304       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46305       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
46306       nextPC = 11 + MATCH_p; 
46307       
46308 #line 1600 "frontend/machine/pentium/decoder.m"
46309       
46310 
46311             stmts = instantiate(pc,  "CMPid", DIS_EADDR32, DIS_I32);
46312 
46313       
46314 
46315       
46316       
46317       
46318     } 
46319     goto MATCH_finished_c; 
46320     
46321   MATCH_label_c499: (void)0; /*placeholder for label*/ 
46322     { 
46323       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46324       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
46325       nextPC = 10 + MATCH_p; 
46326       
46327 #line 1600 "frontend/machine/pentium/decoder.m"
46328       
46329 
46330             stmts = instantiate(pc,  "CMPid", DIS_EADDR32, DIS_I32);
46331 
46332       
46333 
46334       
46335       
46336       
46337     } 
46338     goto MATCH_finished_c; 
46339     
46340   MATCH_label_c500: (void)0; /*placeholder for label*/ 
46341     { 
46342       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46343       int /* [~128..127] */ i8 = 
46344         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
46345       nextPC = 3 + MATCH_p; 
46346       
46347 #line 1594 "frontend/machine/pentium/decoder.m"
46348       
46349 
46350             stmts = instantiate(pc,  "ADDiodb", DIS_EADDR32, DIS_I8);
46351 
46352       
46353 
46354       
46355       
46356       
46357     } 
46358     goto MATCH_finished_c; 
46359     
46360   MATCH_label_c501: (void)0; /*placeholder for label*/ 
46361     { 
46362       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46363       int /* [~128..127] */ i8 = 
46364         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
46365       nextPC = 4 + MATCH_p; 
46366       
46367 #line 1594 "frontend/machine/pentium/decoder.m"
46368       
46369 
46370             stmts = instantiate(pc,  "ADDiodb", DIS_EADDR32, DIS_I8);
46371 
46372       
46373 
46374       
46375       
46376       
46377     } 
46378     goto MATCH_finished_c; 
46379     
46380   MATCH_label_c502: (void)0; /*placeholder for label*/ 
46381     { 
46382       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46383       int /* [~128..127] */ i8 = 
46384         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
46385       nextPC = 8 + MATCH_p; 
46386       
46387 #line 1594 "frontend/machine/pentium/decoder.m"
46388       
46389 
46390             stmts = instantiate(pc,  "ADDiodb", DIS_EADDR32, DIS_I8);
46391 
46392       
46393 
46394       
46395       
46396       
46397     } 
46398     goto MATCH_finished_c; 
46399     
46400   MATCH_label_c503: (void)0; /*placeholder for label*/ 
46401     { 
46402       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46403       int /* [~128..127] */ i8 = 
46404         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
46405       nextPC = 7 + MATCH_p; 
46406       
46407 #line 1594 "frontend/machine/pentium/decoder.m"
46408       
46409 
46410             stmts = instantiate(pc,  "ADDiodb", DIS_EADDR32, DIS_I8);
46411 
46412       
46413 
46414       
46415       
46416       
46417     } 
46418     goto MATCH_finished_c; 
46419     
46420   MATCH_label_c504: (void)0; /*placeholder for label*/ 
46421     { 
46422       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46423       int /* [~128..127] */ i8 = 
46424         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
46425       nextPC = 3 + MATCH_p; 
46426       
46427 #line 1588 "frontend/machine/pentium/decoder.m"
46428       
46429 
46430             stmts = instantiate(pc,  "ORiodb", DIS_EADDR32, DIS_I8);
46431 
46432       
46433 
46434       
46435       
46436       
46437     } 
46438     goto MATCH_finished_c; 
46439     
46440   MATCH_label_c505: (void)0; /*placeholder for label*/ 
46441     { 
46442       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46443       int /* [~128..127] */ i8 = 
46444         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
46445       nextPC = 4 + MATCH_p; 
46446       
46447 #line 1588 "frontend/machine/pentium/decoder.m"
46448       
46449 
46450             stmts = instantiate(pc,  "ORiodb", DIS_EADDR32, DIS_I8);
46451 
46452       
46453 
46454       
46455       
46456       
46457     } 
46458     goto MATCH_finished_c; 
46459     
46460   MATCH_label_c506: (void)0; /*placeholder for label*/ 
46461     { 
46462       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46463       int /* [~128..127] */ i8 = 
46464         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
46465       nextPC = 8 + MATCH_p; 
46466       
46467 #line 1588 "frontend/machine/pentium/decoder.m"
46468       
46469 
46470             stmts = instantiate(pc,  "ORiodb", DIS_EADDR32, DIS_I8);
46471 
46472       
46473 
46474       
46475       
46476       
46477     } 
46478     goto MATCH_finished_c; 
46479     
46480   MATCH_label_c507: (void)0; /*placeholder for label*/ 
46481     { 
46482       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46483       int /* [~128..127] */ i8 = 
46484         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
46485       nextPC = 7 + MATCH_p; 
46486       
46487 #line 1588 "frontend/machine/pentium/decoder.m"
46488       
46489 
46490             stmts = instantiate(pc,  "ORiodb", DIS_EADDR32, DIS_I8);
46491 
46492       
46493 
46494       
46495       
46496       
46497     } 
46498     goto MATCH_finished_c; 
46499     
46500   MATCH_label_c508: (void)0; /*placeholder for label*/ 
46501     { 
46502       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46503       int /* [~128..127] */ i8 = 
46504         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
46505       nextPC = 3 + MATCH_p; 
46506       
46507 #line 1582 "frontend/machine/pentium/decoder.m"
46508       
46509 
46510             stmts = instantiate(pc,  "ADCiodb", DIS_EADDR32, DIS_I8);
46511 
46512       
46513 
46514       
46515       
46516       
46517     } 
46518     goto MATCH_finished_c; 
46519     
46520   MATCH_label_c509: (void)0; /*placeholder for label*/ 
46521     { 
46522       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46523       int /* [~128..127] */ i8 = 
46524         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
46525       nextPC = 4 + MATCH_p; 
46526       
46527 #line 1582 "frontend/machine/pentium/decoder.m"
46528       
46529 
46530             stmts = instantiate(pc,  "ADCiodb", DIS_EADDR32, DIS_I8);
46531 
46532       
46533 
46534       
46535       
46536       
46537     } 
46538     goto MATCH_finished_c; 
46539     
46540   MATCH_label_c510: (void)0; /*placeholder for label*/ 
46541     { 
46542       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46543       int /* [~128..127] */ i8 = 
46544         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
46545       nextPC = 8 + MATCH_p; 
46546       
46547 #line 1582 "frontend/machine/pentium/decoder.m"
46548       
46549 
46550             stmts = instantiate(pc,  "ADCiodb", DIS_EADDR32, DIS_I8);
46551 
46552       
46553 
46554       
46555       
46556       
46557     } 
46558     goto MATCH_finished_c; 
46559     
46560   MATCH_label_c511: (void)0; /*placeholder for label*/ 
46561     { 
46562       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46563       int /* [~128..127] */ i8 = 
46564         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
46565       nextPC = 7 + MATCH_p; 
46566       
46567 #line 1582 "frontend/machine/pentium/decoder.m"
46568       
46569 
46570             stmts = instantiate(pc,  "ADCiodb", DIS_EADDR32, DIS_I8);
46571 
46572       
46573 
46574       
46575       
46576       
46577     } 
46578     goto MATCH_finished_c; 
46579     
46580   MATCH_label_c512: (void)0; /*placeholder for label*/ 
46581     { 
46582       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46583       int /* [~128..127] */ i8 = 
46584         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
46585       nextPC = 3 + MATCH_p; 
46586       
46587 #line 1576 "frontend/machine/pentium/decoder.m"
46588       
46589 
46590             stmts = instantiate(pc,  "SBBiodb", DIS_EADDR32, DIS_I8);
46591 
46592       
46593 
46594       
46595       
46596       
46597     } 
46598     goto MATCH_finished_c; 
46599     
46600   MATCH_label_c513: (void)0; /*placeholder for label*/ 
46601     { 
46602       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46603       int /* [~128..127] */ i8 = 
46604         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
46605       nextPC = 4 + MATCH_p; 
46606       
46607 #line 1576 "frontend/machine/pentium/decoder.m"
46608       
46609 
46610             stmts = instantiate(pc,  "SBBiodb", DIS_EADDR32, DIS_I8);
46611 
46612       
46613 
46614       
46615       
46616       
46617     } 
46618     goto MATCH_finished_c; 
46619     
46620   MATCH_label_c514: (void)0; /*placeholder for label*/ 
46621     { 
46622       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46623       int /* [~128..127] */ i8 = 
46624         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
46625       nextPC = 8 + MATCH_p; 
46626       
46627 #line 1576 "frontend/machine/pentium/decoder.m"
46628       
46629 
46630             stmts = instantiate(pc,  "SBBiodb", DIS_EADDR32, DIS_I8);
46631 
46632       
46633 
46634       
46635       
46636       
46637     } 
46638     goto MATCH_finished_c; 
46639     
46640   MATCH_label_c515: (void)0; /*placeholder for label*/ 
46641     { 
46642       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46643       int /* [~128..127] */ i8 = 
46644         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
46645       nextPC = 7 + MATCH_p; 
46646       
46647 #line 1576 "frontend/machine/pentium/decoder.m"
46648       
46649 
46650             stmts = instantiate(pc,  "SBBiodb", DIS_EADDR32, DIS_I8);
46651 
46652       
46653 
46654       
46655       
46656       
46657     } 
46658     goto MATCH_finished_c; 
46659     
46660   MATCH_label_c516: (void)0; /*placeholder for label*/ 
46661     { 
46662       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46663       int /* [~128..127] */ i8 = 
46664         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
46665       nextPC = 3 + MATCH_p; 
46666       
46667 #line 1567 "frontend/machine/pentium/decoder.m"
46668       
46669 
46670             // Special hack to ignore and $0xfffffff0, %esp
46671 
46672             Exp* oper = dis_Eaddr(Eaddr, 32);
46673 
46674             if (i8 != -16 || !(*oper == *Location::regOf(28)))
46675 
46676                 stmts = instantiate(pc,  "ANDiodb", DIS_EADDR32, DIS_I8);
46677 
46678       
46679 
46680       
46681       
46682       
46683     } 
46684     goto MATCH_finished_c; 
46685     
46686   MATCH_label_c517: (void)0; /*placeholder for label*/ 
46687     { 
46688       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46689       int /* [~128..127] */ i8 = 
46690         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
46691       nextPC = 4 + MATCH_p; 
46692       
46693 #line 1567 "frontend/machine/pentium/decoder.m"
46694       
46695 
46696             // Special hack to ignore and $0xfffffff0, %esp
46697 
46698             Exp* oper = dis_Eaddr(Eaddr, 32);
46699 
46700             if (i8 != -16 || !(*oper == *Location::regOf(28)))
46701 
46702                 stmts = instantiate(pc,  "ANDiodb", DIS_EADDR32, DIS_I8);
46703 
46704       
46705 
46706       
46707       
46708       
46709     } 
46710     goto MATCH_finished_c; 
46711     
46712   MATCH_label_c518: (void)0; /*placeholder for label*/ 
46713     { 
46714       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46715       int /* [~128..127] */ i8 = 
46716         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
46717       nextPC = 8 + MATCH_p; 
46718       
46719 #line 1567 "frontend/machine/pentium/decoder.m"
46720       
46721 
46722             // Special hack to ignore and $0xfffffff0, %esp
46723 
46724             Exp* oper = dis_Eaddr(Eaddr, 32);
46725 
46726             if (i8 != -16 || !(*oper == *Location::regOf(28)))
46727 
46728                 stmts = instantiate(pc,  "ANDiodb", DIS_EADDR32, DIS_I8);
46729 
46730       
46731 
46732       
46733       
46734       
46735     } 
46736     goto MATCH_finished_c; 
46737     
46738   MATCH_label_c519: (void)0; /*placeholder for label*/ 
46739     { 
46740       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46741       int /* [~128..127] */ i8 = 
46742         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
46743       nextPC = 7 + MATCH_p; 
46744       
46745 #line 1567 "frontend/machine/pentium/decoder.m"
46746       
46747 
46748             // Special hack to ignore and $0xfffffff0, %esp
46749 
46750             Exp* oper = dis_Eaddr(Eaddr, 32);
46751 
46752             if (i8 != -16 || !(*oper == *Location::regOf(28)))
46753 
46754                 stmts = instantiate(pc,  "ANDiodb", DIS_EADDR32, DIS_I8);
46755 
46756       
46757 
46758       
46759       
46760       
46761     } 
46762     goto MATCH_finished_c; 
46763     
46764   MATCH_label_c520: (void)0; /*placeholder for label*/ 
46765     { 
46766       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46767       int /* [~128..127] */ i8 = 
46768         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
46769       nextPC = 3 + MATCH_p; 
46770       
46771 #line 1561 "frontend/machine/pentium/decoder.m"
46772       
46773 
46774             stmts = instantiate(pc,  "SUBiodb", DIS_EADDR32, DIS_I8);
46775 
46776       
46777 
46778       
46779       
46780       
46781     } 
46782     goto MATCH_finished_c; 
46783     
46784   MATCH_label_c521: (void)0; /*placeholder for label*/ 
46785     { 
46786       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46787       int /* [~128..127] */ i8 = 
46788         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
46789       nextPC = 4 + MATCH_p; 
46790       
46791 #line 1561 "frontend/machine/pentium/decoder.m"
46792       
46793 
46794             stmts = instantiate(pc,  "SUBiodb", DIS_EADDR32, DIS_I8);
46795 
46796       
46797 
46798       
46799       
46800       
46801     } 
46802     goto MATCH_finished_c; 
46803     
46804   MATCH_label_c522: (void)0; /*placeholder for label*/ 
46805     { 
46806       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46807       int /* [~128..127] */ i8 = 
46808         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
46809       nextPC = 8 + MATCH_p; 
46810       
46811 #line 1561 "frontend/machine/pentium/decoder.m"
46812       
46813 
46814             stmts = instantiate(pc,  "SUBiodb", DIS_EADDR32, DIS_I8);
46815 
46816       
46817 
46818       
46819       
46820       
46821     } 
46822     goto MATCH_finished_c; 
46823     
46824   MATCH_label_c523: (void)0; /*placeholder for label*/ 
46825     { 
46826       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46827       int /* [~128..127] */ i8 = 
46828         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
46829       nextPC = 7 + MATCH_p; 
46830       
46831 #line 1561 "frontend/machine/pentium/decoder.m"
46832       
46833 
46834             stmts = instantiate(pc,  "SUBiodb", DIS_EADDR32, DIS_I8);
46835 
46836       
46837 
46838       
46839       
46840       
46841     } 
46842     goto MATCH_finished_c; 
46843     
46844   MATCH_label_c524: (void)0; /*placeholder for label*/ 
46845     { 
46846       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46847       int /* [~128..127] */ i8 = 
46848         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
46849       nextPC = 3 + MATCH_p; 
46850       
46851 #line 1555 "frontend/machine/pentium/decoder.m"
46852       
46853 
46854             stmts = instantiate(pc,  "XORiodb", DIS_EADDR32, DIS_I8);
46855 
46856       
46857 
46858       
46859       
46860       
46861     } 
46862     goto MATCH_finished_c; 
46863     
46864   MATCH_label_c525: (void)0; /*placeholder for label*/ 
46865     { 
46866       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46867       int /* [~128..127] */ i8 = 
46868         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
46869       nextPC = 4 + MATCH_p; 
46870       
46871 #line 1555 "frontend/machine/pentium/decoder.m"
46872       
46873 
46874             stmts = instantiate(pc,  "XORiodb", DIS_EADDR32, DIS_I8);
46875 
46876       
46877 
46878       
46879       
46880       
46881     } 
46882     goto MATCH_finished_c; 
46883     
46884   MATCH_label_c526: (void)0; /*placeholder for label*/ 
46885     { 
46886       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46887       int /* [~128..127] */ i8 = 
46888         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
46889       nextPC = 8 + MATCH_p; 
46890       
46891 #line 1555 "frontend/machine/pentium/decoder.m"
46892       
46893 
46894             stmts = instantiate(pc,  "XORiodb", DIS_EADDR32, DIS_I8);
46895 
46896       
46897 
46898       
46899       
46900       
46901     } 
46902     goto MATCH_finished_c; 
46903     
46904   MATCH_label_c527: (void)0; /*placeholder for label*/ 
46905     { 
46906       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46907       int /* [~128..127] */ i8 = 
46908         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
46909       nextPC = 7 + MATCH_p; 
46910       
46911 #line 1555 "frontend/machine/pentium/decoder.m"
46912       
46913 
46914             stmts = instantiate(pc,  "XORiodb", DIS_EADDR32, DIS_I8);
46915 
46916       
46917 
46918       
46919       
46920       
46921     } 
46922     goto MATCH_finished_c; 
46923     
46924   MATCH_label_c528: (void)0; /*placeholder for label*/ 
46925     { 
46926       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46927       int /* [~128..127] */ i8 = 
46928         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
46929       nextPC = 3 + MATCH_p; 
46930       
46931 #line 1549 "frontend/machine/pentium/decoder.m"
46932       
46933 
46934             stmts = instantiate(pc,  "CMPiodb", DIS_EADDR32, DIS_I8);
46935 
46936       
46937 
46938       
46939       
46940       
46941     } 
46942     goto MATCH_finished_c; 
46943     
46944   MATCH_label_c529: (void)0; /*placeholder for label*/ 
46945     { 
46946       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46947       int /* [~128..127] */ i8 = 
46948         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
46949       nextPC = 4 + MATCH_p; 
46950       
46951 #line 1549 "frontend/machine/pentium/decoder.m"
46952       
46953 
46954             stmts = instantiate(pc,  "CMPiodb", DIS_EADDR32, DIS_I8);
46955 
46956       
46957 
46958       
46959       
46960       
46961     } 
46962     goto MATCH_finished_c; 
46963     
46964   MATCH_label_c530: (void)0; /*placeholder for label*/ 
46965     { 
46966       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46967       int /* [~128..127] */ i8 = 
46968         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
46969       nextPC = 8 + MATCH_p; 
46970       
46971 #line 1549 "frontend/machine/pentium/decoder.m"
46972       
46973 
46974             stmts = instantiate(pc,  "CMPiodb", DIS_EADDR32, DIS_I8);
46975 
46976       
46977 
46978       
46979       
46980       
46981     } 
46982     goto MATCH_finished_c; 
46983     
46984   MATCH_label_c531: (void)0; /*placeholder for label*/ 
46985     { 
46986       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46987       int /* [~128..127] */ i8 = 
46988         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
46989       nextPC = 7 + MATCH_p; 
46990       
46991 #line 1549 "frontend/machine/pentium/decoder.m"
46992       
46993 
46994             stmts = instantiate(pc,  "CMPiodb", DIS_EADDR32, DIS_I8);
46995 
46996       
46997 
46998       
46999       
47000       
47001     } 
47002     goto MATCH_finished_c; 
47003     
47004   MATCH_label_c532: (void)0; /*placeholder for label*/ 
47005     { 
47006       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47007       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
47008       nextPC = 2 + MATCH_p; 
47009       
47010 #line 384 "frontend/machine/pentium/decoder.m"
47011       
47012 
47013             stmts = instantiate(pc,  "TEST.Eb.Gb", DIS_EADDR8, DIS_REG8);
47014 
47015       
47016 
47017       
47018       
47019       
47020     } 
47021     goto MATCH_finished_c; 
47022     
47023   MATCH_label_c533: (void)0; /*placeholder for label*/ 
47024     { 
47025       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47026       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
47027       nextPC = 3 + MATCH_p; 
47028       
47029 #line 384 "frontend/machine/pentium/decoder.m"
47030       
47031 
47032             stmts = instantiate(pc,  "TEST.Eb.Gb", DIS_EADDR8, DIS_REG8);
47033 
47034       
47035 
47036       
47037       
47038       
47039     } 
47040     goto MATCH_finished_c; 
47041     
47042   MATCH_label_c534: (void)0; /*placeholder for label*/ 
47043     { 
47044       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47045       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
47046       nextPC = 7 + MATCH_p; 
47047       
47048 #line 384 "frontend/machine/pentium/decoder.m"
47049       
47050 
47051             stmts = instantiate(pc,  "TEST.Eb.Gb", DIS_EADDR8, DIS_REG8);
47052 
47053       
47054 
47055       
47056       
47057       
47058     } 
47059     goto MATCH_finished_c; 
47060     
47061   MATCH_label_c535: (void)0; /*placeholder for label*/ 
47062     { 
47063       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47064       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
47065       nextPC = 6 + MATCH_p; 
47066       
47067 #line 384 "frontend/machine/pentium/decoder.m"
47068       
47069 
47070             stmts = instantiate(pc,  "TEST.Eb.Gb", DIS_EADDR8, DIS_REG8);
47071 
47072       
47073 
47074       
47075       
47076       
47077     } 
47078     goto MATCH_finished_c; 
47079     
47080   MATCH_label_c536: (void)0; /*placeholder for label*/ 
47081     { 
47082       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47083       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
47084       nextPC = 2 + MATCH_p; 
47085       
47086 #line 378 "frontend/machine/pentium/decoder.m"
47087       
47088 
47089             stmts = instantiate(pc,  "TEST.Ev.Gvod", DIS_EADDR32, DIS_REG32);
47090 
47091       
47092 
47093       
47094       
47095       
47096     } 
47097     goto MATCH_finished_c; 
47098     
47099   MATCH_label_c537: (void)0; /*placeholder for label*/ 
47100     { 
47101       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47102       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
47103       nextPC = 3 + MATCH_p; 
47104       
47105 #line 378 "frontend/machine/pentium/decoder.m"
47106       
47107 
47108             stmts = instantiate(pc,  "TEST.Ev.Gvod", DIS_EADDR32, DIS_REG32);
47109 
47110       
47111 
47112       
47113       
47114       
47115     } 
47116     goto MATCH_finished_c; 
47117     
47118   MATCH_label_c538: (void)0; /*placeholder for label*/ 
47119     { 
47120       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47121       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
47122       nextPC = 7 + MATCH_p; 
47123       
47124 #line 378 "frontend/machine/pentium/decoder.m"
47125       
47126 
47127             stmts = instantiate(pc,  "TEST.Ev.Gvod", DIS_EADDR32, DIS_REG32);
47128 
47129       
47130 
47131       
47132       
47133       
47134     } 
47135     goto MATCH_finished_c; 
47136     
47137   MATCH_label_c539: (void)0; /*placeholder for label*/ 
47138     { 
47139       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47140       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
47141       nextPC = 6 + MATCH_p; 
47142       
47143 #line 378 "frontend/machine/pentium/decoder.m"
47144       
47145 
47146             stmts = instantiate(pc,  "TEST.Ev.Gvod", DIS_EADDR32, DIS_REG32);
47147 
47148       
47149 
47150       
47151       
47152       
47153     } 
47154     goto MATCH_finished_c; 
47155     
47156   MATCH_label_c540: (void)0; /*placeholder for label*/ 
47157     { 
47158       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47159       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
47160       nextPC = 2 + MATCH_p; 
47161       
47162 #line 324 "frontend/machine/pentium/decoder.m"
47163       
47164 
47165             stmts = instantiate(pc,  "XCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
47166 
47167       
47168 
47169       
47170       
47171       
47172     } 
47173     goto MATCH_finished_c; 
47174     
47175   MATCH_label_c541: (void)0; /*placeholder for label*/ 
47176     { 
47177       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47178       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
47179       nextPC = 3 + MATCH_p; 
47180       
47181 #line 324 "frontend/machine/pentium/decoder.m"
47182       
47183 
47184             stmts = instantiate(pc,  "XCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
47185 
47186       
47187 
47188       
47189       
47190       
47191     } 
47192     goto MATCH_finished_c; 
47193     
47194   MATCH_label_c542: (void)0; /*placeholder for label*/ 
47195     { 
47196       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47197       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
47198       nextPC = 7 + MATCH_p; 
47199       
47200 #line 324 "frontend/machine/pentium/decoder.m"
47201       
47202 
47203             stmts = instantiate(pc,  "XCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
47204 
47205       
47206 
47207       
47208       
47209       
47210     } 
47211     goto MATCH_finished_c; 
47212     
47213   MATCH_label_c543: (void)0; /*placeholder for label*/ 
47214     { 
47215       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47216       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
47217       nextPC = 6 + MATCH_p; 
47218       
47219 #line 324 "frontend/machine/pentium/decoder.m"
47220       
47221 
47222             stmts = instantiate(pc,  "XCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
47223 
47224       
47225 
47226       
47227       
47228       
47229     } 
47230     goto MATCH_finished_c; 
47231     
47232   MATCH_label_c544: (void)0; /*placeholder for label*/ 
47233     { 
47234       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47235       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
47236       nextPC = 2 + MATCH_p; 
47237       
47238 #line 318 "frontend/machine/pentium/decoder.m"
47239       
47240 
47241             stmts = instantiate(pc,  "XCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
47242 
47243       
47244 
47245       
47246       
47247       
47248     } 
47249     goto MATCH_finished_c; 
47250     
47251   MATCH_label_c545: (void)0; /*placeholder for label*/ 
47252     { 
47253       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47254       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
47255       nextPC = 3 + MATCH_p; 
47256       
47257 #line 318 "frontend/machine/pentium/decoder.m"
47258       
47259 
47260             stmts = instantiate(pc,  "XCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
47261 
47262       
47263 
47264       
47265       
47266       
47267     } 
47268     goto MATCH_finished_c; 
47269     
47270   MATCH_label_c546: (void)0; /*placeholder for label*/ 
47271     { 
47272       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47273       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
47274       nextPC = 7 + MATCH_p; 
47275       
47276 #line 318 "frontend/machine/pentium/decoder.m"
47277       
47278 
47279             stmts = instantiate(pc,  "XCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
47280 
47281       
47282 
47283       
47284       
47285       
47286     } 
47287     goto MATCH_finished_c; 
47288     
47289   MATCH_label_c547: (void)0; /*placeholder for label*/ 
47290     { 
47291       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47292       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
47293       nextPC = 6 + MATCH_p; 
47294       
47295 #line 318 "frontend/machine/pentium/decoder.m"
47296       
47297 
47298             stmts = instantiate(pc,  "XCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
47299 
47300       
47301 
47302       
47303       
47304       
47305     } 
47306     goto MATCH_finished_c; 
47307     
47308   MATCH_label_c548: (void)0; /*placeholder for label*/ 
47309     { 
47310       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47311       int /* [~128..127] */ i8 = 
47312         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
47313       nextPC = 3 + MATCH_p; 
47314       
47315 #line 659 "frontend/machine/pentium/decoder.m"
47316       
47317 
47318             stmts = instantiate(pc,  "ROLB.Eb.Ib", DIS_EADDR8, DIS_I8);
47319 
47320       
47321 
47322       
47323       
47324       
47325     } 
47326     goto MATCH_finished_c; 
47327     
47328   MATCH_label_c549: (void)0; /*placeholder for label*/ 
47329     { 
47330       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47331       int /* [~128..127] */ i8 = 
47332         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
47333       nextPC = 4 + MATCH_p; 
47334       
47335 #line 659 "frontend/machine/pentium/decoder.m"
47336       
47337 
47338             stmts = instantiate(pc,  "ROLB.Eb.Ib", DIS_EADDR8, DIS_I8);
47339 
47340       
47341 
47342       
47343       
47344       
47345     } 
47346     goto MATCH_finished_c; 
47347     
47348   MATCH_label_c550: (void)0; /*placeholder for label*/ 
47349     { 
47350       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47351       int /* [~128..127] */ i8 = 
47352         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
47353       nextPC = 8 + MATCH_p; 
47354       
47355 #line 659 "frontend/machine/pentium/decoder.m"
47356       
47357 
47358             stmts = instantiate(pc,  "ROLB.Eb.Ib", DIS_EADDR8, DIS_I8);
47359 
47360       
47361 
47362       
47363       
47364       
47365     } 
47366     goto MATCH_finished_c; 
47367     
47368   MATCH_label_c551: (void)0; /*placeholder for label*/ 
47369     { 
47370       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47371       int /* [~128..127] */ i8 = 
47372         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
47373       nextPC = 7 + MATCH_p; 
47374       
47375 #line 659 "frontend/machine/pentium/decoder.m"
47376       
47377 
47378             stmts = instantiate(pc,  "ROLB.Eb.Ib", DIS_EADDR8, DIS_I8);
47379 
47380       
47381 
47382       
47383       
47384       
47385     } 
47386     goto MATCH_finished_c; 
47387     
47388   MATCH_label_c552: (void)0; /*placeholder for label*/ 
47389     { 
47390       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47391       int /* [~128..127] */ i8 = 
47392         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
47393       nextPC = 3 + MATCH_p; 
47394       
47395 #line 656 "frontend/machine/pentium/decoder.m"
47396       
47397 
47398             stmts = instantiate(pc,  "RORB.Eb.Ib", DIS_EADDR8, DIS_I8);
47399 
47400       
47401 
47402       
47403       
47404       
47405     } 
47406     goto MATCH_finished_c; 
47407     
47408   MATCH_label_c553: (void)0; /*placeholder for label*/ 
47409     { 
47410       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47411       int /* [~128..127] */ i8 = 
47412         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
47413       nextPC = 4 + MATCH_p; 
47414       
47415 #line 656 "frontend/machine/pentium/decoder.m"
47416       
47417 
47418             stmts = instantiate(pc,  "RORB.Eb.Ib", DIS_EADDR8, DIS_I8);
47419 
47420       
47421 
47422       
47423       
47424       
47425     } 
47426     goto MATCH_finished_c; 
47427     
47428   MATCH_label_c554: (void)0; /*placeholder for label*/ 
47429     { 
47430       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47431       int /* [~128..127] */ i8 = 
47432         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
47433       nextPC = 8 + MATCH_p; 
47434       
47435 #line 656 "frontend/machine/pentium/decoder.m"
47436       
47437 
47438             stmts = instantiate(pc,  "RORB.Eb.Ib", DIS_EADDR8, DIS_I8);
47439 
47440       
47441 
47442       
47443       
47444       
47445     } 
47446     goto MATCH_finished_c; 
47447     
47448   MATCH_label_c555: (void)0; /*placeholder for label*/ 
47449     { 
47450       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47451       int /* [~128..127] */ i8 = 
47452         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
47453       nextPC = 7 + MATCH_p; 
47454       
47455 #line 656 "frontend/machine/pentium/decoder.m"
47456       
47457 
47458             stmts = instantiate(pc,  "RORB.Eb.Ib", DIS_EADDR8, DIS_I8);
47459 
47460       
47461 
47462       
47463       
47464       
47465     } 
47466     goto MATCH_finished_c; 
47467     
47468   MATCH_label_c556: (void)0; /*placeholder for label*/ 
47469     { 
47470       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47471       int /* [~128..127] */ i8 = 
47472         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
47473       nextPC = 3 + MATCH_p; 
47474       
47475 #line 653 "frontend/machine/pentium/decoder.m"
47476       
47477 
47478             stmts = instantiate(pc,  "RCLB.Eb.Ib", DIS_EADDR8, DIS_I8);
47479 
47480       
47481 
47482       
47483       
47484       
47485     } 
47486     goto MATCH_finished_c; 
47487     
47488   MATCH_label_c557: (void)0; /*placeholder for label*/ 
47489     { 
47490       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47491       int /* [~128..127] */ i8 = 
47492         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
47493       nextPC = 4 + MATCH_p; 
47494       
47495 #line 653 "frontend/machine/pentium/decoder.m"
47496       
47497 
47498             stmts = instantiate(pc,  "RCLB.Eb.Ib", DIS_EADDR8, DIS_I8);
47499 
47500       
47501 
47502       
47503       
47504       
47505     } 
47506     goto MATCH_finished_c; 
47507     
47508   MATCH_label_c558: (void)0; /*placeholder for label*/ 
47509     { 
47510       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47511       int /* [~128..127] */ i8 = 
47512         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
47513       nextPC = 8 + MATCH_p; 
47514       
47515 #line 653 "frontend/machine/pentium/decoder.m"
47516       
47517 
47518             stmts = instantiate(pc,  "RCLB.Eb.Ib", DIS_EADDR8, DIS_I8);
47519 
47520       
47521 
47522       
47523       
47524       
47525     } 
47526     goto MATCH_finished_c; 
47527     
47528   MATCH_label_c559: (void)0; /*placeholder for label*/ 
47529     { 
47530       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47531       int /* [~128..127] */ i8 = 
47532         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
47533       nextPC = 7 + MATCH_p; 
47534       
47535 #line 653 "frontend/machine/pentium/decoder.m"
47536       
47537 
47538             stmts = instantiate(pc,  "RCLB.Eb.Ib", DIS_EADDR8, DIS_I8);
47539 
47540       
47541 
47542       
47543       
47544       
47545     } 
47546     goto MATCH_finished_c; 
47547     
47548   MATCH_label_c560: (void)0; /*placeholder for label*/ 
47549     { 
47550       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47551       int /* [~128..127] */ i8 = 
47552         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
47553       nextPC = 3 + MATCH_p; 
47554       
47555 #line 650 "frontend/machine/pentium/decoder.m"
47556       
47557 
47558             stmts = instantiate(pc,  "RCRB.Eb.Ib", DIS_EADDR8, DIS_I8);
47559 
47560       
47561 
47562       
47563       
47564       
47565     } 
47566     goto MATCH_finished_c; 
47567     
47568   MATCH_label_c561: (void)0; /*placeholder for label*/ 
47569     { 
47570       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47571       int /* [~128..127] */ i8 = 
47572         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
47573       nextPC = 4 + MATCH_p; 
47574       
47575 #line 650 "frontend/machine/pentium/decoder.m"
47576       
47577 
47578             stmts = instantiate(pc,  "RCRB.Eb.Ib", DIS_EADDR8, DIS_I8);
47579 
47580       
47581 
47582       
47583       
47584       
47585     } 
47586     goto MATCH_finished_c; 
47587     
47588   MATCH_label_c562: (void)0; /*placeholder for label*/ 
47589     { 
47590       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47591       int /* [~128..127] */ i8 = 
47592         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
47593       nextPC = 8 + MATCH_p; 
47594       
47595 #line 650 "frontend/machine/pentium/decoder.m"
47596       
47597 
47598             stmts = instantiate(pc,  "RCRB.Eb.Ib", DIS_EADDR8, DIS_I8);
47599 
47600       
47601 
47602       
47603       
47604       
47605     } 
47606     goto MATCH_finished_c; 
47607     
47608   MATCH_label_c563: (void)0; /*placeholder for label*/ 
47609     { 
47610       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47611       int /* [~128..127] */ i8 = 
47612         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
47613       nextPC = 7 + MATCH_p; 
47614       
47615 #line 650 "frontend/machine/pentium/decoder.m"
47616       
47617 
47618             stmts = instantiate(pc,  "RCRB.Eb.Ib", DIS_EADDR8, DIS_I8);
47619 
47620       
47621 
47622       
47623       
47624       
47625     } 
47626     goto MATCH_finished_c; 
47627     
47628   MATCH_label_c564: (void)0; /*placeholder for label*/ 
47629     { 
47630       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47631       int /* [~128..127] */ i8 = 
47632         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
47633       nextPC = 3 + MATCH_p; 
47634       
47635 #line 647 "frontend/machine/pentium/decoder.m"
47636       
47637 
47638             stmts = instantiate(pc,  "SHLSALB.Eb.Ib", DIS_EADDR8, DIS_I8);
47639 
47640       
47641 
47642       
47643       
47644       
47645     } 
47646     goto MATCH_finished_c; 
47647     
47648   MATCH_label_c565: (void)0; /*placeholder for label*/ 
47649     { 
47650       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47651       int /* [~128..127] */ i8 = 
47652         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
47653       nextPC = 4 + MATCH_p; 
47654       
47655 #line 647 "frontend/machine/pentium/decoder.m"
47656       
47657 
47658             stmts = instantiate(pc,  "SHLSALB.Eb.Ib", DIS_EADDR8, DIS_I8);
47659 
47660       
47661 
47662       
47663       
47664       
47665     } 
47666     goto MATCH_finished_c; 
47667     
47668   MATCH_label_c566: (void)0; /*placeholder for label*/ 
47669     { 
47670       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47671       int /* [~128..127] */ i8 = 
47672         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
47673       nextPC = 8 + MATCH_p; 
47674       
47675 #line 647 "frontend/machine/pentium/decoder.m"
47676       
47677 
47678             stmts = instantiate(pc,  "SHLSALB.Eb.Ib", DIS_EADDR8, DIS_I8);
47679 
47680       
47681 
47682       
47683       
47684       
47685     } 
47686     goto MATCH_finished_c; 
47687     
47688   MATCH_label_c567: (void)0; /*placeholder for label*/ 
47689     { 
47690       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47691       int /* [~128..127] */ i8 = 
47692         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
47693       nextPC = 7 + MATCH_p; 
47694       
47695 #line 647 "frontend/machine/pentium/decoder.m"
47696       
47697 
47698             stmts = instantiate(pc,  "SHLSALB.Eb.Ib", DIS_EADDR8, DIS_I8);
47699 
47700       
47701 
47702       
47703       
47704       
47705     } 
47706     goto MATCH_finished_c; 
47707     
47708   MATCH_label_c568: (void)0; /*placeholder for label*/ 
47709     { 
47710       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47711       int /* [~128..127] */ i8 = 
47712         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
47713       nextPC = 3 + MATCH_p; 
47714       
47715 #line 644 "frontend/machine/pentium/decoder.m"
47716       
47717 
47718             stmts = instantiate(pc,  "SHRB.Eb.Ib", DIS_EADDR8, DIS_I8);
47719 
47720       
47721 
47722       
47723       
47724       
47725     } 
47726     goto MATCH_finished_c; 
47727     
47728   MATCH_label_c569: (void)0; /*placeholder for label*/ 
47729     { 
47730       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47731       int /* [~128..127] */ i8 = 
47732         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
47733       nextPC = 4 + MATCH_p; 
47734       
47735 #line 644 "frontend/machine/pentium/decoder.m"
47736       
47737 
47738             stmts = instantiate(pc,  "SHRB.Eb.Ib", DIS_EADDR8, DIS_I8);
47739 
47740       
47741 
47742       
47743       
47744       
47745     } 
47746     goto MATCH_finished_c; 
47747     
47748   MATCH_label_c570: (void)0; /*placeholder for label*/ 
47749     { 
47750       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47751       int /* [~128..127] */ i8 = 
47752         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
47753       nextPC = 8 + MATCH_p; 
47754       
47755 #line 644 "frontend/machine/pentium/decoder.m"
47756       
47757 
47758             stmts = instantiate(pc,  "SHRB.Eb.Ib", DIS_EADDR8, DIS_I8);
47759 
47760       
47761 
47762       
47763       
47764       
47765     } 
47766     goto MATCH_finished_c; 
47767     
47768   MATCH_label_c571: (void)0; /*placeholder for label*/ 
47769     { 
47770       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47771       int /* [~128..127] */ i8 = 
47772         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
47773       nextPC = 7 + MATCH_p; 
47774       
47775 #line 644 "frontend/machine/pentium/decoder.m"
47776       
47777 
47778             stmts = instantiate(pc,  "SHRB.Eb.Ib", DIS_EADDR8, DIS_I8);
47779 
47780       
47781 
47782       
47783       
47784       
47785     } 
47786     goto MATCH_finished_c; 
47787     
47788   MATCH_label_c572: (void)0; /*placeholder for label*/ 
47789     { 
47790       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47791       int /* [~128..127] */ i8 = 
47792         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
47793       nextPC = 3 + MATCH_p; 
47794       
47795 #line 641 "frontend/machine/pentium/decoder.m"
47796       
47797 
47798             stmts = instantiate(pc,  "SARB.Eb.Ib", DIS_EADDR8, DIS_I8);
47799 
47800       
47801 
47802       
47803       
47804       
47805     } 
47806     goto MATCH_finished_c; 
47807     
47808   MATCH_label_c573: (void)0; /*placeholder for label*/ 
47809     { 
47810       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47811       int /* [~128..127] */ i8 = 
47812         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
47813       nextPC = 4 + MATCH_p; 
47814       
47815 #line 641 "frontend/machine/pentium/decoder.m"
47816       
47817 
47818             stmts = instantiate(pc,  "SARB.Eb.Ib", DIS_EADDR8, DIS_I8);
47819 
47820       
47821 
47822       
47823       
47824       
47825     } 
47826     goto MATCH_finished_c; 
47827     
47828   MATCH_label_c574: (void)0; /*placeholder for label*/ 
47829     { 
47830       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47831       int /* [~128..127] */ i8 = 
47832         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
47833       nextPC = 8 + MATCH_p; 
47834       
47835 #line 641 "frontend/machine/pentium/decoder.m"
47836       
47837 
47838             stmts = instantiate(pc,  "SARB.Eb.Ib", DIS_EADDR8, DIS_I8);
47839 
47840       
47841 
47842       
47843       
47844       
47845     } 
47846     goto MATCH_finished_c; 
47847     
47848   MATCH_label_c575: (void)0; /*placeholder for label*/ 
47849     { 
47850       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47851       int /* [~128..127] */ i8 = 
47852         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
47853       nextPC = 7 + MATCH_p; 
47854       
47855 #line 641 "frontend/machine/pentium/decoder.m"
47856       
47857 
47858             stmts = instantiate(pc,  "SARB.Eb.Ib", DIS_EADDR8, DIS_I8);
47859 
47860       
47861 
47862       
47863       
47864       
47865     } 
47866     goto MATCH_finished_c; 
47867     
47868   MATCH_label_c576: (void)0; /*placeholder for label*/ 
47869     { 
47870       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47871       int /* [~128..127] */ i8 = 
47872         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
47873       nextPC = 3 + MATCH_p; 
47874       
47875 #line 635 "frontend/machine/pentium/decoder.m"
47876       
47877 
47878             stmts = instantiate(pc,  "ROLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
47879 
47880       
47881 
47882       
47883       
47884       
47885     } 
47886     goto MATCH_finished_c; 
47887     
47888   MATCH_label_c577: (void)0; /*placeholder for label*/ 
47889     { 
47890       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47891       int /* [~128..127] */ i8 = 
47892         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
47893       nextPC = 4 + MATCH_p; 
47894       
47895 #line 635 "frontend/machine/pentium/decoder.m"
47896       
47897 
47898             stmts = instantiate(pc,  "ROLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
47899 
47900       
47901 
47902       
47903       
47904       
47905     } 
47906     goto MATCH_finished_c; 
47907     
47908   MATCH_label_c578: (void)0; /*placeholder for label*/ 
47909     { 
47910       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47911       int /* [~128..127] */ i8 = 
47912         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
47913       nextPC = 8 + MATCH_p; 
47914       
47915 #line 635 "frontend/machine/pentium/decoder.m"
47916       
47917 
47918             stmts = instantiate(pc,  "ROLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
47919 
47920       
47921 
47922       
47923       
47924       
47925     } 
47926     goto MATCH_finished_c; 
47927     
47928   MATCH_label_c579: (void)0; /*placeholder for label*/ 
47929     { 
47930       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47931       int /* [~128..127] */ i8 = 
47932         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
47933       nextPC = 7 + MATCH_p; 
47934       
47935 #line 635 "frontend/machine/pentium/decoder.m"
47936       
47937 
47938             stmts = instantiate(pc,  "ROLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
47939 
47940       
47941 
47942       
47943       
47944       
47945     } 
47946     goto MATCH_finished_c; 
47947     
47948   MATCH_label_c580: (void)0; /*placeholder for label*/ 
47949     { 
47950       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47951       int /* [~128..127] */ i8 = 
47952         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
47953       nextPC = 3 + MATCH_p; 
47954       
47955 #line 629 "frontend/machine/pentium/decoder.m"
47956       
47957 
47958             stmts = instantiate(pc,  "RORB.Ev.Ibod", DIS_EADDR32, DIS_I8);
47959 
47960       
47961 
47962       
47963       
47964       
47965     } 
47966     goto MATCH_finished_c; 
47967     
47968   MATCH_label_c581: (void)0; /*placeholder for label*/ 
47969     { 
47970       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47971       int /* [~128..127] */ i8 = 
47972         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
47973       nextPC = 4 + MATCH_p; 
47974       
47975 #line 629 "frontend/machine/pentium/decoder.m"
47976       
47977 
47978             stmts = instantiate(pc,  "RORB.Ev.Ibod", DIS_EADDR32, DIS_I8);
47979 
47980       
47981 
47982       
47983       
47984       
47985     } 
47986     goto MATCH_finished_c; 
47987     
47988   MATCH_label_c582: (void)0; /*placeholder for label*/ 
47989     { 
47990       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47991       int /* [~128..127] */ i8 = 
47992         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
47993       nextPC = 8 + MATCH_p; 
47994       
47995 #line 629 "frontend/machine/pentium/decoder.m"
47996       
47997 
47998             stmts = instantiate(pc,  "RORB.Ev.Ibod", DIS_EADDR32, DIS_I8);
47999 
48000       
48001 
48002       
48003       
48004       
48005     } 
48006     goto MATCH_finished_c; 
48007     
48008   MATCH_label_c583: (void)0; /*placeholder for label*/ 
48009     { 
48010       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48011       int /* [~128..127] */ i8 = 
48012         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
48013       nextPC = 7 + MATCH_p; 
48014       
48015 #line 629 "frontend/machine/pentium/decoder.m"
48016       
48017 
48018             stmts = instantiate(pc,  "RORB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48019 
48020       
48021 
48022       
48023       
48024       
48025     } 
48026     goto MATCH_finished_c; 
48027     
48028   MATCH_label_c584: (void)0; /*placeholder for label*/ 
48029     { 
48030       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48031       int /* [~128..127] */ i8 = 
48032         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
48033       nextPC = 3 + MATCH_p; 
48034       
48035 #line 623 "frontend/machine/pentium/decoder.m"
48036       
48037 
48038             stmts = instantiate(pc,  "RCLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48039 
48040       
48041 
48042       
48043       
48044       
48045     } 
48046     goto MATCH_finished_c; 
48047     
48048   MATCH_label_c585: (void)0; /*placeholder for label*/ 
48049     { 
48050       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48051       int /* [~128..127] */ i8 = 
48052         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
48053       nextPC = 4 + MATCH_p; 
48054       
48055 #line 623 "frontend/machine/pentium/decoder.m"
48056       
48057 
48058             stmts = instantiate(pc,  "RCLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48059 
48060       
48061 
48062       
48063       
48064       
48065     } 
48066     goto MATCH_finished_c; 
48067     
48068   MATCH_label_c586: (void)0; /*placeholder for label*/ 
48069     { 
48070       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48071       int /* [~128..127] */ i8 = 
48072         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
48073       nextPC = 8 + MATCH_p; 
48074       
48075 #line 623 "frontend/machine/pentium/decoder.m"
48076       
48077 
48078             stmts = instantiate(pc,  "RCLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48079 
48080       
48081 
48082       
48083       
48084       
48085     } 
48086     goto MATCH_finished_c; 
48087     
48088   MATCH_label_c587: (void)0; /*placeholder for label*/ 
48089     { 
48090       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48091       int /* [~128..127] */ i8 = 
48092         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
48093       nextPC = 7 + MATCH_p; 
48094       
48095 #line 623 "frontend/machine/pentium/decoder.m"
48096       
48097 
48098             stmts = instantiate(pc,  "RCLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48099 
48100       
48101 
48102       
48103       
48104       
48105     } 
48106     goto MATCH_finished_c; 
48107     
48108   MATCH_label_c588: (void)0; /*placeholder for label*/ 
48109     { 
48110       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48111       int /* [~128..127] */ i8 = 
48112         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
48113       nextPC = 3 + MATCH_p; 
48114       
48115 #line 617 "frontend/machine/pentium/decoder.m"
48116       
48117 
48118             stmts = instantiate(pc,  "RCRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48119 
48120       
48121 
48122       
48123       
48124       
48125     } 
48126     goto MATCH_finished_c; 
48127     
48128   MATCH_label_c589: (void)0; /*placeholder for label*/ 
48129     { 
48130       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48131       int /* [~128..127] */ i8 = 
48132         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
48133       nextPC = 4 + MATCH_p; 
48134       
48135 #line 617 "frontend/machine/pentium/decoder.m"
48136       
48137 
48138             stmts = instantiate(pc,  "RCRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48139 
48140       
48141 
48142       
48143       
48144       
48145     } 
48146     goto MATCH_finished_c; 
48147     
48148   MATCH_label_c590: (void)0; /*placeholder for label*/ 
48149     { 
48150       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48151       int /* [~128..127] */ i8 = 
48152         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
48153       nextPC = 8 + MATCH_p; 
48154       
48155 #line 617 "frontend/machine/pentium/decoder.m"
48156       
48157 
48158             stmts = instantiate(pc,  "RCRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48159 
48160       
48161 
48162       
48163       
48164       
48165     } 
48166     goto MATCH_finished_c; 
48167     
48168   MATCH_label_c591: (void)0; /*placeholder for label*/ 
48169     { 
48170       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48171       int /* [~128..127] */ i8 = 
48172         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
48173       nextPC = 7 + MATCH_p; 
48174       
48175 #line 617 "frontend/machine/pentium/decoder.m"
48176       
48177 
48178             stmts = instantiate(pc,  "RCRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48179 
48180       
48181 
48182       
48183       
48184       
48185     } 
48186     goto MATCH_finished_c; 
48187     
48188   MATCH_label_c592: (void)0; /*placeholder for label*/ 
48189     { 
48190       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48191       int /* [~128..127] */ i8 = 
48192         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
48193       nextPC = 3 + MATCH_p; 
48194       
48195 #line 611 "frontend/machine/pentium/decoder.m"
48196       
48197 
48198             stmts = instantiate(pc,  "SHLSALB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48199 
48200       
48201 
48202       
48203       
48204       
48205     } 
48206     goto MATCH_finished_c; 
48207     
48208   MATCH_label_c593: (void)0; /*placeholder for label*/ 
48209     { 
48210       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48211       int /* [~128..127] */ i8 = 
48212         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
48213       nextPC = 4 + MATCH_p; 
48214       
48215 #line 611 "frontend/machine/pentium/decoder.m"
48216       
48217 
48218             stmts = instantiate(pc,  "SHLSALB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48219 
48220       
48221 
48222       
48223       
48224       
48225     } 
48226     goto MATCH_finished_c; 
48227     
48228   MATCH_label_c594: (void)0; /*placeholder for label*/ 
48229     { 
48230       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48231       int /* [~128..127] */ i8 = 
48232         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
48233       nextPC = 8 + MATCH_p; 
48234       
48235 #line 611 "frontend/machine/pentium/decoder.m"
48236       
48237 
48238             stmts = instantiate(pc,  "SHLSALB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48239 
48240       
48241 
48242       
48243       
48244       
48245     } 
48246     goto MATCH_finished_c; 
48247     
48248   MATCH_label_c595: (void)0; /*placeholder for label*/ 
48249     { 
48250       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48251       int /* [~128..127] */ i8 = 
48252         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
48253       nextPC = 7 + MATCH_p; 
48254       
48255 #line 611 "frontend/machine/pentium/decoder.m"
48256       
48257 
48258             stmts = instantiate(pc,  "SHLSALB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48259 
48260       
48261 
48262       
48263       
48264       
48265     } 
48266     goto MATCH_finished_c; 
48267     
48268   MATCH_label_c596: (void)0; /*placeholder for label*/ 
48269     { 
48270       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48271       int /* [~128..127] */ i8 = 
48272         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
48273       nextPC = 3 + MATCH_p; 
48274       
48275 #line 605 "frontend/machine/pentium/decoder.m"
48276       
48277 
48278             stmts = instantiate(pc,  "SHRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48279 
48280       
48281 
48282       
48283       
48284       
48285     } 
48286     goto MATCH_finished_c; 
48287     
48288   MATCH_label_c597: (void)0; /*placeholder for label*/ 
48289     { 
48290       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48291       int /* [~128..127] */ i8 = 
48292         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
48293       nextPC = 4 + MATCH_p; 
48294       
48295 #line 605 "frontend/machine/pentium/decoder.m"
48296       
48297 
48298             stmts = instantiate(pc,  "SHRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48299 
48300       
48301 
48302       
48303       
48304       
48305     } 
48306     goto MATCH_finished_c; 
48307     
48308   MATCH_label_c598: (void)0; /*placeholder for label*/ 
48309     { 
48310       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48311       int /* [~128..127] */ i8 = 
48312         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
48313       nextPC = 8 + MATCH_p; 
48314       
48315 #line 605 "frontend/machine/pentium/decoder.m"
48316       
48317 
48318             stmts = instantiate(pc,  "SHRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48319 
48320       
48321 
48322       
48323       
48324       
48325     } 
48326     goto MATCH_finished_c; 
48327     
48328   MATCH_label_c599: (void)0; /*placeholder for label*/ 
48329     { 
48330       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48331       int /* [~128..127] */ i8 = 
48332         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
48333       nextPC = 7 + MATCH_p; 
48334       
48335 #line 605 "frontend/machine/pentium/decoder.m"
48336       
48337 
48338             stmts = instantiate(pc,  "SHRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48339 
48340       
48341 
48342       
48343       
48344       
48345     } 
48346     goto MATCH_finished_c; 
48347     
48348   MATCH_label_c600: (void)0; /*placeholder for label*/ 
48349     { 
48350       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48351       int /* [~128..127] */ i8 = 
48352         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
48353       nextPC = 3 + MATCH_p; 
48354       
48355 #line 599 "frontend/machine/pentium/decoder.m"
48356       
48357 
48358             stmts = instantiate(pc,  "SARB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48359 
48360       
48361 
48362       
48363       
48364       
48365     } 
48366     goto MATCH_finished_c; 
48367     
48368   MATCH_label_c601: (void)0; /*placeholder for label*/ 
48369     { 
48370       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48371       int /* [~128..127] */ i8 = 
48372         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
48373       nextPC = 4 + MATCH_p; 
48374       
48375 #line 599 "frontend/machine/pentium/decoder.m"
48376       
48377 
48378             stmts = instantiate(pc,  "SARB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48379 
48380       
48381 
48382       
48383       
48384       
48385     } 
48386     goto MATCH_finished_c; 
48387     
48388   MATCH_label_c602: (void)0; /*placeholder for label*/ 
48389     { 
48390       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48391       int /* [~128..127] */ i8 = 
48392         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
48393       nextPC = 8 + MATCH_p; 
48394       
48395 #line 599 "frontend/machine/pentium/decoder.m"
48396       
48397 
48398             stmts = instantiate(pc,  "SARB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48399 
48400       
48401 
48402       
48403       
48404       
48405     } 
48406     goto MATCH_finished_c; 
48407     
48408   MATCH_label_c603: (void)0; /*placeholder for label*/ 
48409     { 
48410       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48411       int /* [~128..127] */ i8 = 
48412         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
48413       nextPC = 7 + MATCH_p; 
48414       
48415 #line 599 "frontend/machine/pentium/decoder.m"
48416       
48417 
48418             stmts = instantiate(pc,  "SARB.Ev.Ibod", DIS_EADDR32, DIS_I8);
48419 
48420       
48421 
48422       
48423       
48424       
48425     } 
48426     goto MATCH_finished_c; 
48427     
48428   MATCH_label_c604: (void)0; /*placeholder for label*/ 
48429     { 
48430       unsigned Mem = 1 + addressToPC(MATCH_p);
48431       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48432       nextPC = 3 + MATCH_p; 
48433       
48434 #line 1067 "frontend/machine/pentium/decoder.m"
48435       
48436 
48437             stmts = instantiate(pc,  "LES", DIS_REG32, DIS_MEM);
48438 
48439       
48440 
48441       
48442       
48443       
48444     } 
48445     goto MATCH_finished_c; 
48446     
48447   MATCH_label_c605: (void)0; /*placeholder for label*/ 
48448     { 
48449       unsigned Mem = 1 + addressToPC(MATCH_p);
48450       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48451       nextPC = 7 + MATCH_p; 
48452       
48453 #line 1067 "frontend/machine/pentium/decoder.m"
48454       
48455 
48456             stmts = instantiate(pc,  "LES", DIS_REG32, DIS_MEM);
48457 
48458       
48459 
48460       
48461       
48462       
48463     } 
48464     goto MATCH_finished_c; 
48465     
48466   MATCH_label_c606: (void)0; /*placeholder for label*/ 
48467     { 
48468       unsigned Mem = 1 + addressToPC(MATCH_p);
48469       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48470       nextPC = 6 + MATCH_p; 
48471       
48472 #line 1067 "frontend/machine/pentium/decoder.m"
48473       
48474 
48475             stmts = instantiate(pc,  "LES", DIS_REG32, DIS_MEM);
48476 
48477       
48478 
48479       
48480       
48481       
48482     } 
48483     goto MATCH_finished_c; 
48484     
48485   MATCH_label_c607: (void)0; /*placeholder for label*/ 
48486     { 
48487       unsigned Mem = 1 + addressToPC(MATCH_p);
48488       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48489       nextPC = 3 + MATCH_p; 
48490       
48491 #line 1079 "frontend/machine/pentium/decoder.m"
48492       
48493 
48494             stmts = instantiate(pc,  "LDS", DIS_REG32, DIS_MEM);
48495 
48496       
48497 
48498       
48499       
48500       
48501     } 
48502     goto MATCH_finished_c; 
48503     
48504   MATCH_label_c608: (void)0; /*placeholder for label*/ 
48505     { 
48506       unsigned Mem = 1 + addressToPC(MATCH_p);
48507       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48508       nextPC = 7 + MATCH_p; 
48509       
48510 #line 1079 "frontend/machine/pentium/decoder.m"
48511       
48512 
48513             stmts = instantiate(pc,  "LDS", DIS_REG32, DIS_MEM);
48514 
48515       
48516 
48517       
48518       
48519       
48520     } 
48521     goto MATCH_finished_c; 
48522     
48523   MATCH_label_c609: (void)0; /*placeholder for label*/ 
48524     { 
48525       unsigned Mem = 1 + addressToPC(MATCH_p);
48526       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48527       nextPC = 6 + MATCH_p; 
48528       
48529 #line 1079 "frontend/machine/pentium/decoder.m"
48530       
48531 
48532             stmts = instantiate(pc,  "LDS", DIS_REG32, DIS_MEM);
48533 
48534       
48535 
48536       
48537       
48538       
48539     } 
48540     goto MATCH_finished_c; 
48541     
48542   MATCH_label_c610: (void)0; /*placeholder for label*/ 
48543     { 
48544       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48545       int /* [~128..127] */ i8 = 
48546         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
48547       nextPC = 3 + MATCH_p; 
48548       
48549 #line 986 "frontend/machine/pentium/decoder.m"
48550       
48551 
48552             stmts = instantiate(pc,  "MOV.Eb.Ib", DIS_EADDR8, DIS_I8);
48553 
48554       
48555 
48556       
48557       
48558       
48559     } 
48560     goto MATCH_finished_c; 
48561     
48562   MATCH_label_c611: (void)0; /*placeholder for label*/ 
48563     { 
48564       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48565       int /* [~128..127] */ i8 = 
48566         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
48567       nextPC = 4 + MATCH_p; 
48568       
48569 #line 986 "frontend/machine/pentium/decoder.m"
48570       
48571 
48572             stmts = instantiate(pc,  "MOV.Eb.Ib", DIS_EADDR8, DIS_I8);
48573 
48574       
48575 
48576       
48577       
48578       
48579     } 
48580     goto MATCH_finished_c; 
48581     
48582   MATCH_label_c612: (void)0; /*placeholder for label*/ 
48583     { 
48584       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48585       int /* [~128..127] */ i8 = 
48586         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
48587       nextPC = 8 + MATCH_p; 
48588       
48589 #line 986 "frontend/machine/pentium/decoder.m"
48590       
48591 
48592             stmts = instantiate(pc,  "MOV.Eb.Ib", DIS_EADDR8, DIS_I8);
48593 
48594       
48595 
48596       
48597       
48598       
48599     } 
48600     goto MATCH_finished_c; 
48601     
48602   MATCH_label_c613: (void)0; /*placeholder for label*/ 
48603     { 
48604       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48605       int /* [~128..127] */ i8 = 
48606         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
48607       nextPC = 7 + MATCH_p; 
48608       
48609 #line 986 "frontend/machine/pentium/decoder.m"
48610       
48611 
48612             stmts = instantiate(pc,  "MOV.Eb.Ib", DIS_EADDR8, DIS_I8);
48613 
48614       
48615 
48616       
48617       
48618       
48619     } 
48620     goto MATCH_finished_c; 
48621     
48622   MATCH_label_c614: (void)0; /*placeholder for label*/ 
48623     { 
48624       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48625       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
48626       nextPC = 6 + MATCH_p; 
48627       
48628 #line 980 "frontend/machine/pentium/decoder.m"
48629       
48630 
48631             stmts = instantiate(pc,  "MOV.Ed.Ivod", DIS_EADDR32, DIS_I32);
48632 
48633       
48634 
48635       
48636       
48637       
48638     } 
48639     goto MATCH_finished_c; 
48640     
48641   MATCH_label_c615: (void)0; /*placeholder for label*/ 
48642     { 
48643       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48644       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
48645       nextPC = 7 + MATCH_p; 
48646       
48647 #line 980 "frontend/machine/pentium/decoder.m"
48648       
48649 
48650             stmts = instantiate(pc,  "MOV.Ed.Ivod", DIS_EADDR32, DIS_I32);
48651 
48652       
48653 
48654       
48655       
48656       
48657     } 
48658     goto MATCH_finished_c; 
48659     
48660   MATCH_label_c616: (void)0; /*placeholder for label*/ 
48661     { 
48662       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48663       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
48664       nextPC = 11 + MATCH_p; 
48665       
48666 #line 980 "frontend/machine/pentium/decoder.m"
48667       
48668 
48669             stmts = instantiate(pc,  "MOV.Ed.Ivod", DIS_EADDR32, DIS_I32);
48670 
48671       
48672 
48673       
48674       
48675       
48676     } 
48677     goto MATCH_finished_c; 
48678     
48679   MATCH_label_c617: (void)0; /*placeholder for label*/ 
48680     { 
48681       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48682       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
48683       nextPC = 10 + MATCH_p; 
48684       
48685 #line 980 "frontend/machine/pentium/decoder.m"
48686       
48687 
48688             stmts = instantiate(pc,  "MOV.Ed.Ivod", DIS_EADDR32, DIS_I32);
48689 
48690       
48691 
48692       
48693       
48694       
48695     } 
48696     goto MATCH_finished_c; 
48697     
48698   MATCH_label_c618: (void)0; /*placeholder for label*/ 
48699     { 
48700       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48701       nextPC = 2 + MATCH_p; 
48702       
48703 #line 785 "frontend/machine/pentium/decoder.m"
48704       
48705 
48706             stmts = instantiate(pc,  "ROLB.Eb.1", DIS_EADDR8);
48707 
48708       
48709 
48710         // There is no SSL for these, so don't call instantiate, it will only
48711 
48712         // cause an assert failure. Also, may as well treat these as invalid instr
48713 
48714       //      | PUSHFod() =>
48715 
48716       //          stmts = instantiate(pc,  "PUSHFod");
48717 
48718       
48719 
48720       //      | PUSHFow() =>
48721 
48722       //          stmts = instantiate(pc,  "PUSHFow");
48723 
48724       
48725 
48726       //      | PUSHAod() =>
48727 
48728       //          stmts = instantiate(pc,  "PUSHAod");
48729 
48730       
48731 
48732       //      | PUSHAow() =>
48733 
48734       //          stmts = instantiate(pc,  "PUSHAow");
48735 
48736       
48737 
48738       
48739       
48740       
48741     } 
48742     goto MATCH_finished_c; 
48743     
48744   MATCH_label_c619: (void)0; /*placeholder for label*/ 
48745     { 
48746       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48747       nextPC = 3 + MATCH_p; 
48748       
48749 #line 785 "frontend/machine/pentium/decoder.m"
48750       
48751 
48752             stmts = instantiate(pc,  "ROLB.Eb.1", DIS_EADDR8);
48753 
48754       
48755 
48756         // There is no SSL for these, so don't call instantiate, it will only
48757 
48758         // cause an assert failure. Also, may as well treat these as invalid instr
48759 
48760       //      | PUSHFod() =>
48761 
48762       //          stmts = instantiate(pc,  "PUSHFod");
48763 
48764       
48765 
48766       //      | PUSHFow() =>
48767 
48768       //          stmts = instantiate(pc,  "PUSHFow");
48769 
48770       
48771 
48772       //      | PUSHAod() =>
48773 
48774       //          stmts = instantiate(pc,  "PUSHAod");
48775 
48776       
48777 
48778       //      | PUSHAow() =>
48779 
48780       //          stmts = instantiate(pc,  "PUSHAow");
48781 
48782       
48783 
48784       
48785       
48786       
48787     } 
48788     goto MATCH_finished_c; 
48789     
48790   MATCH_label_c620: (void)0; /*placeholder for label*/ 
48791     { 
48792       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48793       nextPC = 7 + MATCH_p; 
48794       
48795 #line 785 "frontend/machine/pentium/decoder.m"
48796       
48797 
48798             stmts = instantiate(pc,  "ROLB.Eb.1", DIS_EADDR8);
48799 
48800       
48801 
48802         // There is no SSL for these, so don't call instantiate, it will only
48803 
48804         // cause an assert failure. Also, may as well treat these as invalid instr
48805 
48806       //      | PUSHFod() =>
48807 
48808       //          stmts = instantiate(pc,  "PUSHFod");
48809 
48810       
48811 
48812       //      | PUSHFow() =>
48813 
48814       //          stmts = instantiate(pc,  "PUSHFow");
48815 
48816       
48817 
48818       //      | PUSHAod() =>
48819 
48820       //          stmts = instantiate(pc,  "PUSHAod");
48821 
48822       
48823 
48824       //      | PUSHAow() =>
48825 
48826       //          stmts = instantiate(pc,  "PUSHAow");
48827 
48828       
48829 
48830       
48831       
48832       
48833     } 
48834     goto MATCH_finished_c; 
48835     
48836   MATCH_label_c621: (void)0; /*placeholder for label*/ 
48837     { 
48838       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48839       nextPC = 6 + MATCH_p; 
48840       
48841 #line 785 "frontend/machine/pentium/decoder.m"
48842       
48843 
48844             stmts = instantiate(pc,  "ROLB.Eb.1", DIS_EADDR8);
48845 
48846       
48847 
48848         // There is no SSL for these, so don't call instantiate, it will only
48849 
48850         // cause an assert failure. Also, may as well treat these as invalid instr
48851 
48852       //      | PUSHFod() =>
48853 
48854       //          stmts = instantiate(pc,  "PUSHFod");
48855 
48856       
48857 
48858       //      | PUSHFow() =>
48859 
48860       //          stmts = instantiate(pc,  "PUSHFow");
48861 
48862       
48863 
48864       //      | PUSHAod() =>
48865 
48866       //          stmts = instantiate(pc,  "PUSHAod");
48867 
48868       
48869 
48870       //      | PUSHAow() =>
48871 
48872       //          stmts = instantiate(pc,  "PUSHAow");
48873 
48874       
48875 
48876       
48877       
48878       
48879     } 
48880     goto MATCH_finished_c; 
48881     
48882   MATCH_label_c622: (void)0; /*placeholder for label*/ 
48883     { 
48884       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48885       nextPC = 2 + MATCH_p; 
48886       
48887 #line 779 "frontend/machine/pentium/decoder.m"
48888       
48889 
48890             stmts = instantiate(pc,  "RORB.Eb.1", DIS_EADDR8);
48891 
48892       
48893 
48894       
48895       
48896       
48897     } 
48898     goto MATCH_finished_c; 
48899     
48900   MATCH_label_c623: (void)0; /*placeholder for label*/ 
48901     { 
48902       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48903       nextPC = 3 + MATCH_p; 
48904       
48905 #line 779 "frontend/machine/pentium/decoder.m"
48906       
48907 
48908             stmts = instantiate(pc,  "RORB.Eb.1", DIS_EADDR8);
48909 
48910       
48911 
48912       
48913       
48914       
48915     } 
48916     goto MATCH_finished_c; 
48917     
48918   MATCH_label_c624: (void)0; /*placeholder for label*/ 
48919     { 
48920       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48921       nextPC = 7 + MATCH_p; 
48922       
48923 #line 779 "frontend/machine/pentium/decoder.m"
48924       
48925 
48926             stmts = instantiate(pc,  "RORB.Eb.1", DIS_EADDR8);
48927 
48928       
48929 
48930       
48931       
48932       
48933     } 
48934     goto MATCH_finished_c; 
48935     
48936   MATCH_label_c625: (void)0; /*placeholder for label*/ 
48937     { 
48938       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48939       nextPC = 6 + MATCH_p; 
48940       
48941 #line 779 "frontend/machine/pentium/decoder.m"
48942       
48943 
48944             stmts = instantiate(pc,  "RORB.Eb.1", DIS_EADDR8);
48945 
48946       
48947 
48948       
48949       
48950       
48951     } 
48952     goto MATCH_finished_c; 
48953     
48954   MATCH_label_c626: (void)0; /*placeholder for label*/ 
48955     { 
48956       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48957       nextPC = 2 + MATCH_p; 
48958       
48959 #line 773 "frontend/machine/pentium/decoder.m"
48960       
48961 
48962             stmts = instantiate(pc,  "RCLB.Eb.1", DIS_EADDR8);
48963 
48964       
48965 
48966       
48967       
48968       
48969     } 
48970     goto MATCH_finished_c; 
48971     
48972   MATCH_label_c627: (void)0; /*placeholder for label*/ 
48973     { 
48974       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48975       nextPC = 3 + MATCH_p; 
48976       
48977 #line 773 "frontend/machine/pentium/decoder.m"
48978       
48979 
48980             stmts = instantiate(pc,  "RCLB.Eb.1", DIS_EADDR8);
48981 
48982       
48983 
48984       
48985       
48986       
48987     } 
48988     goto MATCH_finished_c; 
48989     
48990   MATCH_label_c628: (void)0; /*placeholder for label*/ 
48991     { 
48992       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48993       nextPC = 7 + MATCH_p; 
48994       
48995 #line 773 "frontend/machine/pentium/decoder.m"
48996       
48997 
48998             stmts = instantiate(pc,  "RCLB.Eb.1", DIS_EADDR8);
48999 
49000       
49001 
49002       
49003       
49004       
49005     } 
49006     goto MATCH_finished_c; 
49007     
49008   MATCH_label_c629: (void)0; /*placeholder for label*/ 
49009     { 
49010       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49011       nextPC = 6 + MATCH_p; 
49012       
49013 #line 773 "frontend/machine/pentium/decoder.m"
49014       
49015 
49016             stmts = instantiate(pc,  "RCLB.Eb.1", DIS_EADDR8);
49017 
49018       
49019 
49020       
49021       
49022       
49023     } 
49024     goto MATCH_finished_c; 
49025     
49026   MATCH_label_c630: (void)0; /*placeholder for label*/ 
49027     { 
49028       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49029       nextPC = 2 + MATCH_p; 
49030       
49031 #line 767 "frontend/machine/pentium/decoder.m"
49032       
49033 
49034             stmts = instantiate(pc,  "RCRB.Eb.1", DIS_EADDR8);
49035 
49036       
49037 
49038       
49039       
49040       
49041     } 
49042     goto MATCH_finished_c; 
49043     
49044   MATCH_label_c631: (void)0; /*placeholder for label*/ 
49045     { 
49046       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49047       nextPC = 3 + MATCH_p; 
49048       
49049 #line 767 "frontend/machine/pentium/decoder.m"
49050       
49051 
49052             stmts = instantiate(pc,  "RCRB.Eb.1", DIS_EADDR8);
49053 
49054       
49055 
49056       
49057       
49058       
49059     } 
49060     goto MATCH_finished_c; 
49061     
49062   MATCH_label_c632: (void)0; /*placeholder for label*/ 
49063     { 
49064       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49065       nextPC = 7 + MATCH_p; 
49066       
49067 #line 767 "frontend/machine/pentium/decoder.m"
49068       
49069 
49070             stmts = instantiate(pc,  "RCRB.Eb.1", DIS_EADDR8);
49071 
49072       
49073 
49074       
49075       
49076       
49077     } 
49078     goto MATCH_finished_c; 
49079     
49080   MATCH_label_c633: (void)0; /*placeholder for label*/ 
49081     { 
49082       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49083       nextPC = 6 + MATCH_p; 
49084       
49085 #line 767 "frontend/machine/pentium/decoder.m"
49086       
49087 
49088             stmts = instantiate(pc,  "RCRB.Eb.1", DIS_EADDR8);
49089 
49090       
49091 
49092       
49093       
49094       
49095     } 
49096     goto MATCH_finished_c; 
49097     
49098   MATCH_label_c634: (void)0; /*placeholder for label*/ 
49099     { 
49100       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49101       nextPC = 2 + MATCH_p; 
49102       
49103 #line 761 "frontend/machine/pentium/decoder.m"
49104       
49105 
49106             stmts = instantiate(pc,  "SHLSALB.Eb.1", DIS_EADDR8);
49107 
49108       
49109 
49110       
49111       
49112       
49113     } 
49114     goto MATCH_finished_c; 
49115     
49116   MATCH_label_c635: (void)0; /*placeholder for label*/ 
49117     { 
49118       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49119       nextPC = 3 + MATCH_p; 
49120       
49121 #line 761 "frontend/machine/pentium/decoder.m"
49122       
49123 
49124             stmts = instantiate(pc,  "SHLSALB.Eb.1", DIS_EADDR8);
49125 
49126       
49127 
49128       
49129       
49130       
49131     } 
49132     goto MATCH_finished_c; 
49133     
49134   MATCH_label_c636: (void)0; /*placeholder for label*/ 
49135     { 
49136       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49137       nextPC = 7 + MATCH_p; 
49138       
49139 #line 761 "frontend/machine/pentium/decoder.m"
49140       
49141 
49142             stmts = instantiate(pc,  "SHLSALB.Eb.1", DIS_EADDR8);
49143 
49144       
49145 
49146       
49147       
49148       
49149     } 
49150     goto MATCH_finished_c; 
49151     
49152   MATCH_label_c637: (void)0; /*placeholder for label*/ 
49153     { 
49154       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49155       nextPC = 6 + MATCH_p; 
49156       
49157 #line 761 "frontend/machine/pentium/decoder.m"
49158       
49159 
49160             stmts = instantiate(pc,  "SHLSALB.Eb.1", DIS_EADDR8);
49161 
49162       
49163 
49164       
49165       
49166       
49167     } 
49168     goto MATCH_finished_c; 
49169     
49170   MATCH_label_c638: (void)0; /*placeholder for label*/ 
49171     { 
49172       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49173       nextPC = 2 + MATCH_p; 
49174       
49175 #line 755 "frontend/machine/pentium/decoder.m"
49176       
49177 
49178             stmts = instantiate(pc,  "SHRB.Eb.1", DIS_EADDR8);
49179 
49180       
49181 
49182       
49183       
49184       
49185     } 
49186     goto MATCH_finished_c; 
49187     
49188   MATCH_label_c639: (void)0; /*placeholder for label*/ 
49189     { 
49190       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49191       nextPC = 3 + MATCH_p; 
49192       
49193 #line 755 "frontend/machine/pentium/decoder.m"
49194       
49195 
49196             stmts = instantiate(pc,  "SHRB.Eb.1", DIS_EADDR8);
49197 
49198       
49199 
49200       
49201       
49202       
49203     } 
49204     goto MATCH_finished_c; 
49205     
49206   MATCH_label_c640: (void)0; /*placeholder for label*/ 
49207     { 
49208       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49209       nextPC = 7 + MATCH_p; 
49210       
49211 #line 755 "frontend/machine/pentium/decoder.m"
49212       
49213 
49214             stmts = instantiate(pc,  "SHRB.Eb.1", DIS_EADDR8);
49215 
49216       
49217 
49218       
49219       
49220       
49221     } 
49222     goto MATCH_finished_c; 
49223     
49224   MATCH_label_c641: (void)0; /*placeholder for label*/ 
49225     { 
49226       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49227       nextPC = 6 + MATCH_p; 
49228       
49229 #line 755 "frontend/machine/pentium/decoder.m"
49230       
49231 
49232             stmts = instantiate(pc,  "SHRB.Eb.1", DIS_EADDR8);
49233 
49234       
49235 
49236       
49237       
49238       
49239     } 
49240     goto MATCH_finished_c; 
49241     
49242   MATCH_label_c642: (void)0; /*placeholder for label*/ 
49243     { 
49244       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49245       nextPC = 2 + MATCH_p; 
49246       
49247 #line 749 "frontend/machine/pentium/decoder.m"
49248       
49249 
49250             stmts = instantiate(pc,  "SARB.Eb.1", DIS_EADDR16);
49251 
49252       
49253 
49254       
49255       
49256       
49257     } 
49258     goto MATCH_finished_c; 
49259     
49260   MATCH_label_c643: (void)0; /*placeholder for label*/ 
49261     { 
49262       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49263       nextPC = 3 + MATCH_p; 
49264       
49265 #line 749 "frontend/machine/pentium/decoder.m"
49266       
49267 
49268             stmts = instantiate(pc,  "SARB.Eb.1", DIS_EADDR16);
49269 
49270       
49271 
49272       
49273       
49274       
49275     } 
49276     goto MATCH_finished_c; 
49277     
49278   MATCH_label_c644: (void)0; /*placeholder for label*/ 
49279     { 
49280       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49281       nextPC = 7 + MATCH_p; 
49282       
49283 #line 749 "frontend/machine/pentium/decoder.m"
49284       
49285 
49286             stmts = instantiate(pc,  "SARB.Eb.1", DIS_EADDR16);
49287 
49288       
49289 
49290       
49291       
49292       
49293     } 
49294     goto MATCH_finished_c; 
49295     
49296   MATCH_label_c645: (void)0; /*placeholder for label*/ 
49297     { 
49298       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49299       nextPC = 6 + MATCH_p; 
49300       
49301 #line 749 "frontend/machine/pentium/decoder.m"
49302       
49303 
49304             stmts = instantiate(pc,  "SARB.Eb.1", DIS_EADDR16);
49305 
49306       
49307 
49308       
49309       
49310       
49311     } 
49312     goto MATCH_finished_c; 
49313     
49314   MATCH_label_c646: (void)0; /*placeholder for label*/ 
49315     { 
49316       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49317       nextPC = 2 + MATCH_p; 
49318       
49319 #line 740 "frontend/machine/pentium/decoder.m"
49320       
49321 
49322             stmts = instantiate(pc,  "ROLB.Ev.1od", DIS_EADDR32);
49323 
49324       
49325 
49326       
49327       
49328       
49329     } 
49330     goto MATCH_finished_c; 
49331     
49332   MATCH_label_c647: (void)0; /*placeholder for label*/ 
49333     { 
49334       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49335       nextPC = 3 + MATCH_p; 
49336       
49337 #line 740 "frontend/machine/pentium/decoder.m"
49338       
49339 
49340             stmts = instantiate(pc,  "ROLB.Ev.1od", DIS_EADDR32);
49341 
49342       
49343 
49344       
49345       
49346       
49347     } 
49348     goto MATCH_finished_c; 
49349     
49350   MATCH_label_c648: (void)0; /*placeholder for label*/ 
49351     { 
49352       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49353       nextPC = 7 + MATCH_p; 
49354       
49355 #line 740 "frontend/machine/pentium/decoder.m"
49356       
49357 
49358             stmts = instantiate(pc,  "ROLB.Ev.1od", DIS_EADDR32);
49359 
49360       
49361 
49362       
49363       
49364       
49365     } 
49366     goto MATCH_finished_c; 
49367     
49368   MATCH_label_c649: (void)0; /*placeholder for label*/ 
49369     { 
49370       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49371       nextPC = 6 + MATCH_p; 
49372       
49373 #line 740 "frontend/machine/pentium/decoder.m"
49374       
49375 
49376             stmts = instantiate(pc,  "ROLB.Ev.1od", DIS_EADDR32);
49377 
49378       
49379 
49380       
49381       
49382       
49383     } 
49384     goto MATCH_finished_c; 
49385     
49386   MATCH_label_c650: (void)0; /*placeholder for label*/ 
49387     { 
49388       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49389       nextPC = 2 + MATCH_p; 
49390       
49391 #line 728 "frontend/machine/pentium/decoder.m"
49392       
49393 
49394             stmts = instantiate(pc,  "RORB.Ev.1od", DIS_EADDR32);
49395 
49396       
49397 
49398       
49399       
49400       
49401     } 
49402     goto MATCH_finished_c; 
49403     
49404   MATCH_label_c651: (void)0; /*placeholder for label*/ 
49405     { 
49406       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49407       nextPC = 3 + MATCH_p; 
49408       
49409 #line 728 "frontend/machine/pentium/decoder.m"
49410       
49411 
49412             stmts = instantiate(pc,  "RORB.Ev.1od", DIS_EADDR32);
49413 
49414       
49415 
49416       
49417       
49418       
49419     } 
49420     goto MATCH_finished_c; 
49421     
49422   MATCH_label_c652: (void)0; /*placeholder for label*/ 
49423     { 
49424       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49425       nextPC = 7 + MATCH_p; 
49426       
49427 #line 728 "frontend/machine/pentium/decoder.m"
49428       
49429 
49430             stmts = instantiate(pc,  "RORB.Ev.1od", DIS_EADDR32);
49431 
49432       
49433 
49434       
49435       
49436       
49437     } 
49438     goto MATCH_finished_c; 
49439     
49440   MATCH_label_c653: (void)0; /*placeholder for label*/ 
49441     { 
49442       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49443       nextPC = 6 + MATCH_p; 
49444       
49445 #line 728 "frontend/machine/pentium/decoder.m"
49446       
49447 
49448             stmts = instantiate(pc,  "RORB.Ev.1od", DIS_EADDR32);
49449 
49450       
49451 
49452       
49453       
49454       
49455     } 
49456     goto MATCH_finished_c; 
49457     
49458   MATCH_label_c654: (void)0; /*placeholder for label*/ 
49459     { 
49460       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49461       nextPC = 2 + MATCH_p; 
49462       
49463 #line 716 "frontend/machine/pentium/decoder.m"
49464       
49465 
49466             stmts = instantiate(pc,  "RCLB.Ev.1od", DIS_EADDR32);
49467 
49468       
49469 
49470       
49471       
49472       
49473     } 
49474     goto MATCH_finished_c; 
49475     
49476   MATCH_label_c655: (void)0; /*placeholder for label*/ 
49477     { 
49478       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49479       nextPC = 3 + MATCH_p; 
49480       
49481 #line 716 "frontend/machine/pentium/decoder.m"
49482       
49483 
49484             stmts = instantiate(pc,  "RCLB.Ev.1od", DIS_EADDR32);
49485 
49486       
49487 
49488       
49489       
49490       
49491     } 
49492     goto MATCH_finished_c; 
49493     
49494   MATCH_label_c656: (void)0; /*placeholder for label*/ 
49495     { 
49496       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49497       nextPC = 7 + MATCH_p; 
49498       
49499 #line 716 "frontend/machine/pentium/decoder.m"
49500       
49501 
49502             stmts = instantiate(pc,  "RCLB.Ev.1od", DIS_EADDR32);
49503 
49504       
49505 
49506       
49507       
49508       
49509     } 
49510     goto MATCH_finished_c; 
49511     
49512   MATCH_label_c657: (void)0; /*placeholder for label*/ 
49513     { 
49514       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49515       nextPC = 6 + MATCH_p; 
49516       
49517 #line 716 "frontend/machine/pentium/decoder.m"
49518       
49519 
49520             stmts = instantiate(pc,  "RCLB.Ev.1od", DIS_EADDR32);
49521 
49522       
49523 
49524       
49525       
49526       
49527     } 
49528     goto MATCH_finished_c; 
49529     
49530   MATCH_label_c658: (void)0; /*placeholder for label*/ 
49531     { 
49532       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49533       nextPC = 2 + MATCH_p; 
49534       
49535 #line 704 "frontend/machine/pentium/decoder.m"
49536       
49537 
49538             stmts = instantiate(pc,  "RCRB.Ev.1od", DIS_EADDR32);
49539 
49540       
49541 
49542       
49543       
49544       
49545     } 
49546     goto MATCH_finished_c; 
49547     
49548   MATCH_label_c659: (void)0; /*placeholder for label*/ 
49549     { 
49550       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49551       nextPC = 3 + MATCH_p; 
49552       
49553 #line 704 "frontend/machine/pentium/decoder.m"
49554       
49555 
49556             stmts = instantiate(pc,  "RCRB.Ev.1od", DIS_EADDR32);
49557 
49558       
49559 
49560       
49561       
49562       
49563     } 
49564     goto MATCH_finished_c; 
49565     
49566   MATCH_label_c660: (void)0; /*placeholder for label*/ 
49567     { 
49568       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49569       nextPC = 7 + MATCH_p; 
49570       
49571 #line 704 "frontend/machine/pentium/decoder.m"
49572       
49573 
49574             stmts = instantiate(pc,  "RCRB.Ev.1od", DIS_EADDR32);
49575 
49576       
49577 
49578       
49579       
49580       
49581     } 
49582     goto MATCH_finished_c; 
49583     
49584   MATCH_label_c661: (void)0; /*placeholder for label*/ 
49585     { 
49586       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49587       nextPC = 6 + MATCH_p; 
49588       
49589 #line 704 "frontend/machine/pentium/decoder.m"
49590       
49591 
49592             stmts = instantiate(pc,  "RCRB.Ev.1od", DIS_EADDR32);
49593 
49594       
49595 
49596       
49597       
49598       
49599     } 
49600     goto MATCH_finished_c; 
49601     
49602   MATCH_label_c662: (void)0; /*placeholder for label*/ 
49603     { 
49604       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49605       nextPC = 2 + MATCH_p; 
49606       
49607 #line 692 "frontend/machine/pentium/decoder.m"
49608       
49609 
49610             stmts = instantiate(pc,  "SHLSALB.Ev.1od", DIS_EADDR32);
49611 
49612       
49613 
49614       
49615       
49616       
49617     } 
49618     goto MATCH_finished_c; 
49619     
49620   MATCH_label_c663: (void)0; /*placeholder for label*/ 
49621     { 
49622       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49623       nextPC = 3 + MATCH_p; 
49624       
49625 #line 692 "frontend/machine/pentium/decoder.m"
49626       
49627 
49628             stmts = instantiate(pc,  "SHLSALB.Ev.1od", DIS_EADDR32);
49629 
49630       
49631 
49632       
49633       
49634       
49635     } 
49636     goto MATCH_finished_c; 
49637     
49638   MATCH_label_c664: (void)0; /*placeholder for label*/ 
49639     { 
49640       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49641       nextPC = 7 + MATCH_p; 
49642       
49643 #line 692 "frontend/machine/pentium/decoder.m"
49644       
49645 
49646             stmts = instantiate(pc,  "SHLSALB.Ev.1od", DIS_EADDR32);
49647 
49648       
49649 
49650       
49651       
49652       
49653     } 
49654     goto MATCH_finished_c; 
49655     
49656   MATCH_label_c665: (void)0; /*placeholder for label*/ 
49657     { 
49658       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49659       nextPC = 6 + MATCH_p; 
49660       
49661 #line 692 "frontend/machine/pentium/decoder.m"
49662       
49663 
49664             stmts = instantiate(pc,  "SHLSALB.Ev.1od", DIS_EADDR32);
49665 
49666       
49667 
49668       
49669       
49670       
49671     } 
49672     goto MATCH_finished_c; 
49673     
49674   MATCH_label_c666: (void)0; /*placeholder for label*/ 
49675     { 
49676       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49677       nextPC = 2 + MATCH_p; 
49678       
49679 #line 680 "frontend/machine/pentium/decoder.m"
49680       
49681 
49682             stmts = instantiate(pc,  "SHRB.Ev.1od", DIS_EADDR32);
49683 
49684       
49685 
49686       
49687       
49688       
49689     } 
49690     goto MATCH_finished_c; 
49691     
49692   MATCH_label_c667: (void)0; /*placeholder for label*/ 
49693     { 
49694       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49695       nextPC = 3 + MATCH_p; 
49696       
49697 #line 680 "frontend/machine/pentium/decoder.m"
49698       
49699 
49700             stmts = instantiate(pc,  "SHRB.Ev.1od", DIS_EADDR32);
49701 
49702       
49703 
49704       
49705       
49706       
49707     } 
49708     goto MATCH_finished_c; 
49709     
49710   MATCH_label_c668: (void)0; /*placeholder for label*/ 
49711     { 
49712       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49713       nextPC = 7 + MATCH_p; 
49714       
49715 #line 680 "frontend/machine/pentium/decoder.m"
49716       
49717 
49718             stmts = instantiate(pc,  "SHRB.Ev.1od", DIS_EADDR32);
49719 
49720       
49721 
49722       
49723       
49724       
49725     } 
49726     goto MATCH_finished_c; 
49727     
49728   MATCH_label_c669: (void)0; /*placeholder for label*/ 
49729     { 
49730       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49731       nextPC = 6 + MATCH_p; 
49732       
49733 #line 680 "frontend/machine/pentium/decoder.m"
49734       
49735 
49736             stmts = instantiate(pc,  "SHRB.Ev.1od", DIS_EADDR32);
49737 
49738       
49739 
49740       
49741       
49742       
49743     } 
49744     goto MATCH_finished_c; 
49745     
49746   MATCH_label_c670: (void)0; /*placeholder for label*/ 
49747     { 
49748       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49749       nextPC = 2 + MATCH_p; 
49750       
49751 #line 668 "frontend/machine/pentium/decoder.m"
49752       
49753 
49754             stmts = instantiate(pc,  "SARB.Ev.1od", DIS_EADDR32);
49755 
49756       
49757 
49758       
49759       
49760       
49761     } 
49762     goto MATCH_finished_c; 
49763     
49764   MATCH_label_c671: (void)0; /*placeholder for label*/ 
49765     { 
49766       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49767       nextPC = 3 + MATCH_p; 
49768       
49769 #line 668 "frontend/machine/pentium/decoder.m"
49770       
49771 
49772             stmts = instantiate(pc,  "SARB.Ev.1od", DIS_EADDR32);
49773 
49774       
49775 
49776       
49777       
49778       
49779     } 
49780     goto MATCH_finished_c; 
49781     
49782   MATCH_label_c672: (void)0; /*placeholder for label*/ 
49783     { 
49784       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49785       nextPC = 7 + MATCH_p; 
49786       
49787 #line 668 "frontend/machine/pentium/decoder.m"
49788       
49789 
49790             stmts = instantiate(pc,  "SARB.Ev.1od", DIS_EADDR32);
49791 
49792       
49793 
49794       
49795       
49796       
49797     } 
49798     goto MATCH_finished_c; 
49799     
49800   MATCH_label_c673: (void)0; /*placeholder for label*/ 
49801     { 
49802       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49803       nextPC = 6 + MATCH_p; 
49804       
49805 #line 668 "frontend/machine/pentium/decoder.m"
49806       
49807 
49808             stmts = instantiate(pc,  "SARB.Ev.1od", DIS_EADDR32);
49809 
49810       
49811 
49812       
49813       
49814       
49815     } 
49816     goto MATCH_finished_c; 
49817     
49818   MATCH_label_c674: (void)0; /*placeholder for label*/ 
49819     { 
49820       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49821       nextPC = 2 + MATCH_p; 
49822       
49823 #line 782 "frontend/machine/pentium/decoder.m"
49824       
49825 
49826             stmts = instantiate(pc,  "ROLB.Eb.CL", DIS_EADDR8);
49827 
49828       
49829 
49830       
49831       
49832       
49833     } 
49834     goto MATCH_finished_c; 
49835     
49836   MATCH_label_c675: (void)0; /*placeholder for label*/ 
49837     { 
49838       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49839       nextPC = 3 + MATCH_p; 
49840       
49841 #line 782 "frontend/machine/pentium/decoder.m"
49842       
49843 
49844             stmts = instantiate(pc,  "ROLB.Eb.CL", DIS_EADDR8);
49845 
49846       
49847 
49848       
49849       
49850       
49851     } 
49852     goto MATCH_finished_c; 
49853     
49854   MATCH_label_c676: (void)0; /*placeholder for label*/ 
49855     { 
49856       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49857       nextPC = 7 + MATCH_p; 
49858       
49859 #line 782 "frontend/machine/pentium/decoder.m"
49860       
49861 
49862             stmts = instantiate(pc,  "ROLB.Eb.CL", DIS_EADDR8);
49863 
49864       
49865 
49866       
49867       
49868       
49869     } 
49870     goto MATCH_finished_c; 
49871     
49872   MATCH_label_c677: (void)0; /*placeholder for label*/ 
49873     { 
49874       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49875       nextPC = 6 + MATCH_p; 
49876       
49877 #line 782 "frontend/machine/pentium/decoder.m"
49878       
49879 
49880             stmts = instantiate(pc,  "ROLB.Eb.CL", DIS_EADDR8);
49881 
49882       
49883 
49884       
49885       
49886       
49887     } 
49888     goto MATCH_finished_c; 
49889     
49890   MATCH_label_c678: (void)0; /*placeholder for label*/ 
49891     { 
49892       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49893       nextPC = 2 + MATCH_p; 
49894       
49895 #line 776 "frontend/machine/pentium/decoder.m"
49896       
49897 
49898             stmts = instantiate(pc,  "RORB.Eb.CL", DIS_EADDR8);
49899 
49900       
49901 
49902       
49903       
49904       
49905     } 
49906     goto MATCH_finished_c; 
49907     
49908   MATCH_label_c679: (void)0; /*placeholder for label*/ 
49909     { 
49910       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49911       nextPC = 3 + MATCH_p; 
49912       
49913 #line 776 "frontend/machine/pentium/decoder.m"
49914       
49915 
49916             stmts = instantiate(pc,  "RORB.Eb.CL", DIS_EADDR8);
49917 
49918       
49919 
49920       
49921       
49922       
49923     } 
49924     goto MATCH_finished_c; 
49925     
49926   MATCH_label_c680: (void)0; /*placeholder for label*/ 
49927     { 
49928       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49929       nextPC = 7 + MATCH_p; 
49930       
49931 #line 776 "frontend/machine/pentium/decoder.m"
49932       
49933 
49934             stmts = instantiate(pc,  "RORB.Eb.CL", DIS_EADDR8);
49935 
49936       
49937 
49938       
49939       
49940       
49941     } 
49942     goto MATCH_finished_c; 
49943     
49944   MATCH_label_c681: (void)0; /*placeholder for label*/ 
49945     { 
49946       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49947       nextPC = 6 + MATCH_p; 
49948       
49949 #line 776 "frontend/machine/pentium/decoder.m"
49950       
49951 
49952             stmts = instantiate(pc,  "RORB.Eb.CL", DIS_EADDR8);
49953 
49954       
49955 
49956       
49957       
49958       
49959     } 
49960     goto MATCH_finished_c; 
49961     
49962   MATCH_label_c682: (void)0; /*placeholder for label*/ 
49963     { 
49964       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49965       nextPC = 2 + MATCH_p; 
49966       
49967 #line 770 "frontend/machine/pentium/decoder.m"
49968       
49969 
49970             stmts = instantiate(pc,  "RCLB.Eb.CL", DIS_EADDR8);
49971 
49972       
49973 
49974       
49975       
49976       
49977     } 
49978     goto MATCH_finished_c; 
49979     
49980   MATCH_label_c683: (void)0; /*placeholder for label*/ 
49981     { 
49982       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49983       nextPC = 3 + MATCH_p; 
49984       
49985 #line 770 "frontend/machine/pentium/decoder.m"
49986       
49987 
49988             stmts = instantiate(pc,  "RCLB.Eb.CL", DIS_EADDR8);
49989 
49990       
49991 
49992       
49993       
49994       
49995     } 
49996     goto MATCH_finished_c; 
49997     
49998   MATCH_label_c684: (void)0; /*placeholder for label*/ 
49999     { 
50000       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50001       nextPC = 7 + MATCH_p; 
50002       
50003 #line 770 "frontend/machine/pentium/decoder.m"
50004       
50005 
50006             stmts = instantiate(pc,  "RCLB.Eb.CL", DIS_EADDR8);
50007 
50008       
50009 
50010       
50011       
50012       
50013     } 
50014     goto MATCH_finished_c; 
50015     
50016   MATCH_label_c685: (void)0; /*placeholder for label*/ 
50017     { 
50018       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50019       nextPC = 6 + MATCH_p; 
50020       
50021 #line 770 "frontend/machine/pentium/decoder.m"
50022       
50023 
50024             stmts = instantiate(pc,  "RCLB.Eb.CL", DIS_EADDR8);
50025 
50026       
50027 
50028       
50029       
50030       
50031     } 
50032     goto MATCH_finished_c; 
50033     
50034   MATCH_label_c686: (void)0; /*placeholder for label*/ 
50035     { 
50036       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50037       nextPC = 2 + MATCH_p; 
50038       
50039 #line 764 "frontend/machine/pentium/decoder.m"
50040       
50041 
50042             stmts = instantiate(pc,  "RCRB.Eb.CL", DIS_EADDR8);
50043 
50044       
50045 
50046       
50047       
50048       
50049     } 
50050     goto MATCH_finished_c; 
50051     
50052   MATCH_label_c687: (void)0; /*placeholder for label*/ 
50053     { 
50054       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50055       nextPC = 3 + MATCH_p; 
50056       
50057 #line 764 "frontend/machine/pentium/decoder.m"
50058       
50059 
50060             stmts = instantiate(pc,  "RCRB.Eb.CL", DIS_EADDR8);
50061 
50062       
50063 
50064       
50065       
50066       
50067     } 
50068     goto MATCH_finished_c; 
50069     
50070   MATCH_label_c688: (void)0; /*placeholder for label*/ 
50071     { 
50072       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50073       nextPC = 7 + MATCH_p; 
50074       
50075 #line 764 "frontend/machine/pentium/decoder.m"
50076       
50077 
50078             stmts = instantiate(pc,  "RCRB.Eb.CL", DIS_EADDR8);
50079 
50080       
50081 
50082       
50083       
50084       
50085     } 
50086     goto MATCH_finished_c; 
50087     
50088   MATCH_label_c689: (void)0; /*placeholder for label*/ 
50089     { 
50090       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50091       nextPC = 6 + MATCH_p; 
50092       
50093 #line 764 "frontend/machine/pentium/decoder.m"
50094       
50095 
50096             stmts = instantiate(pc,  "RCRB.Eb.CL", DIS_EADDR8);
50097 
50098       
50099 
50100       
50101       
50102       
50103     } 
50104     goto MATCH_finished_c; 
50105     
50106   MATCH_label_c690: (void)0; /*placeholder for label*/ 
50107     { 
50108       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50109       nextPC = 2 + MATCH_p; 
50110       
50111 #line 758 "frontend/machine/pentium/decoder.m"
50112       
50113 
50114             stmts = instantiate(pc,  "SHLSALB.Eb.CL", DIS_EADDR8);
50115 
50116       
50117 
50118       
50119       
50120       
50121     } 
50122     goto MATCH_finished_c; 
50123     
50124   MATCH_label_c691: (void)0; /*placeholder for label*/ 
50125     { 
50126       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50127       nextPC = 3 + MATCH_p; 
50128       
50129 #line 758 "frontend/machine/pentium/decoder.m"
50130       
50131 
50132             stmts = instantiate(pc,  "SHLSALB.Eb.CL", DIS_EADDR8);
50133 
50134       
50135 
50136       
50137       
50138       
50139     } 
50140     goto MATCH_finished_c; 
50141     
50142   MATCH_label_c692: (void)0; /*placeholder for label*/ 
50143     { 
50144       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50145       nextPC = 7 + MATCH_p; 
50146       
50147 #line 758 "frontend/machine/pentium/decoder.m"
50148       
50149 
50150             stmts = instantiate(pc,  "SHLSALB.Eb.CL", DIS_EADDR8);
50151 
50152       
50153 
50154       
50155       
50156       
50157     } 
50158     goto MATCH_finished_c; 
50159     
50160   MATCH_label_c693: (void)0; /*placeholder for label*/ 
50161     { 
50162       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50163       nextPC = 6 + MATCH_p; 
50164       
50165 #line 758 "frontend/machine/pentium/decoder.m"
50166       
50167 
50168             stmts = instantiate(pc,  "SHLSALB.Eb.CL", DIS_EADDR8);
50169 
50170       
50171 
50172       
50173       
50174       
50175     } 
50176     goto MATCH_finished_c; 
50177     
50178   MATCH_label_c694: (void)0; /*placeholder for label*/ 
50179     { 
50180       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50181       nextPC = 2 + MATCH_p; 
50182       
50183 #line 752 "frontend/machine/pentium/decoder.m"
50184       
50185 
50186             stmts = instantiate(pc,  "SHRB.Eb.CL", DIS_EADDR8);
50187 
50188       
50189 
50190       
50191       
50192       
50193     } 
50194     goto MATCH_finished_c; 
50195     
50196   MATCH_label_c695: (void)0; /*placeholder for label*/ 
50197     { 
50198       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50199       nextPC = 3 + MATCH_p; 
50200       
50201 #line 752 "frontend/machine/pentium/decoder.m"
50202       
50203 
50204             stmts = instantiate(pc,  "SHRB.Eb.CL", DIS_EADDR8);
50205 
50206       
50207 
50208       
50209       
50210       
50211     } 
50212     goto MATCH_finished_c; 
50213     
50214   MATCH_label_c696: (void)0; /*placeholder for label*/ 
50215     { 
50216       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50217       nextPC = 7 + MATCH_p; 
50218       
50219 #line 752 "frontend/machine/pentium/decoder.m"
50220       
50221 
50222             stmts = instantiate(pc,  "SHRB.Eb.CL", DIS_EADDR8);
50223 
50224       
50225 
50226       
50227       
50228       
50229     } 
50230     goto MATCH_finished_c; 
50231     
50232   MATCH_label_c697: (void)0; /*placeholder for label*/ 
50233     { 
50234       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50235       nextPC = 6 + MATCH_p; 
50236       
50237 #line 752 "frontend/machine/pentium/decoder.m"
50238       
50239 
50240             stmts = instantiate(pc,  "SHRB.Eb.CL", DIS_EADDR8);
50241 
50242       
50243 
50244       
50245       
50246       
50247     } 
50248     goto MATCH_finished_c; 
50249     
50250   MATCH_label_c698: (void)0; /*placeholder for label*/ 
50251     { 
50252       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50253       nextPC = 2 + MATCH_p; 
50254       
50255 #line 746 "frontend/machine/pentium/decoder.m"
50256       
50257 
50258             stmts = instantiate(pc,  "SARB.Eb.CL", DIS_EADDR32);
50259 
50260       
50261 
50262       
50263       
50264       
50265     } 
50266     goto MATCH_finished_c; 
50267     
50268   MATCH_label_c699: (void)0; /*placeholder for label*/ 
50269     { 
50270       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50271       nextPC = 3 + MATCH_p; 
50272       
50273 #line 746 "frontend/machine/pentium/decoder.m"
50274       
50275 
50276             stmts = instantiate(pc,  "SARB.Eb.CL", DIS_EADDR32);
50277 
50278       
50279 
50280       
50281       
50282       
50283     } 
50284     goto MATCH_finished_c; 
50285     
50286   MATCH_label_c700: (void)0; /*placeholder for label*/ 
50287     { 
50288       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50289       nextPC = 7 + MATCH_p; 
50290       
50291 #line 746 "frontend/machine/pentium/decoder.m"
50292       
50293 
50294             stmts = instantiate(pc,  "SARB.Eb.CL", DIS_EADDR32);
50295 
50296       
50297 
50298       
50299       
50300       
50301     } 
50302     goto MATCH_finished_c; 
50303     
50304   MATCH_label_c701: (void)0; /*placeholder for label*/ 
50305     { 
50306       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50307       nextPC = 6 + MATCH_p; 
50308       
50309 #line 746 "frontend/machine/pentium/decoder.m"
50310       
50311 
50312             stmts = instantiate(pc,  "SARB.Eb.CL", DIS_EADDR32);
50313 
50314       
50315 
50316       
50317       
50318       
50319     } 
50320     goto MATCH_finished_c; 
50321     
50322   MATCH_label_c702: (void)0; /*placeholder for label*/ 
50323     { 
50324       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50325       nextPC = 2 + MATCH_p; 
50326       
50327 #line 734 "frontend/machine/pentium/decoder.m"
50328       
50329 
50330             stmts = instantiate(pc,  "ROLB.Ev.CLod", DIS_EADDR32);
50331 
50332       
50333 
50334       
50335       
50336       
50337     } 
50338     goto MATCH_finished_c; 
50339     
50340   MATCH_label_c703: (void)0; /*placeholder for label*/ 
50341     { 
50342       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50343       nextPC = 3 + MATCH_p; 
50344       
50345 #line 734 "frontend/machine/pentium/decoder.m"
50346       
50347 
50348             stmts = instantiate(pc,  "ROLB.Ev.CLod", DIS_EADDR32);
50349 
50350       
50351 
50352       
50353       
50354       
50355     } 
50356     goto MATCH_finished_c; 
50357     
50358   MATCH_label_c704: (void)0; /*placeholder for label*/ 
50359     { 
50360       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50361       nextPC = 7 + MATCH_p; 
50362       
50363 #line 734 "frontend/machine/pentium/decoder.m"
50364       
50365 
50366             stmts = instantiate(pc,  "ROLB.Ev.CLod", DIS_EADDR32);
50367 
50368       
50369 
50370       
50371       
50372       
50373     } 
50374     goto MATCH_finished_c; 
50375     
50376   MATCH_label_c705: (void)0; /*placeholder for label*/ 
50377     { 
50378       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50379       nextPC = 6 + MATCH_p; 
50380       
50381 #line 734 "frontend/machine/pentium/decoder.m"
50382       
50383 
50384             stmts = instantiate(pc,  "ROLB.Ev.CLod", DIS_EADDR32);
50385 
50386       
50387 
50388       
50389       
50390       
50391     } 
50392     goto MATCH_finished_c; 
50393     
50394   MATCH_label_c706: (void)0; /*placeholder for label*/ 
50395     { 
50396       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50397       nextPC = 2 + MATCH_p; 
50398       
50399 #line 722 "frontend/machine/pentium/decoder.m"
50400       
50401 
50402             stmts = instantiate(pc,  "RORB.Ev.CLod", DIS_EADDR32);
50403 
50404       
50405 
50406       
50407       
50408       
50409     } 
50410     goto MATCH_finished_c; 
50411     
50412   MATCH_label_c707: (void)0; /*placeholder for label*/ 
50413     { 
50414       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50415       nextPC = 3 + MATCH_p; 
50416       
50417 #line 722 "frontend/machine/pentium/decoder.m"
50418       
50419 
50420             stmts = instantiate(pc,  "RORB.Ev.CLod", DIS_EADDR32);
50421 
50422       
50423 
50424       
50425       
50426       
50427     } 
50428     goto MATCH_finished_c; 
50429     
50430   MATCH_label_c708: (void)0; /*placeholder for label*/ 
50431     { 
50432       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50433       nextPC = 7 + MATCH_p; 
50434       
50435 #line 722 "frontend/machine/pentium/decoder.m"
50436       
50437 
50438             stmts = instantiate(pc,  "RORB.Ev.CLod", DIS_EADDR32);
50439 
50440       
50441 
50442       
50443       
50444       
50445     } 
50446     goto MATCH_finished_c; 
50447     
50448   MATCH_label_c709: (void)0; /*placeholder for label*/ 
50449     { 
50450       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50451       nextPC = 6 + MATCH_p; 
50452       
50453 #line 722 "frontend/machine/pentium/decoder.m"
50454       
50455 
50456             stmts = instantiate(pc,  "RORB.Ev.CLod", DIS_EADDR32);
50457 
50458       
50459 
50460       
50461       
50462       
50463     } 
50464     goto MATCH_finished_c; 
50465     
50466   MATCH_label_c710: (void)0; /*placeholder for label*/ 
50467     { 
50468       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50469       nextPC = 2 + MATCH_p; 
50470       
50471 #line 710 "frontend/machine/pentium/decoder.m"
50472       
50473 
50474             stmts = instantiate(pc,  "RCLB.Ev.CLod", DIS_EADDR32);
50475 
50476       
50477 
50478       
50479       
50480       
50481     } 
50482     goto MATCH_finished_c; 
50483     
50484   MATCH_label_c711: (void)0; /*placeholder for label*/ 
50485     { 
50486       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50487       nextPC = 3 + MATCH_p; 
50488       
50489 #line 710 "frontend/machine/pentium/decoder.m"
50490       
50491 
50492             stmts = instantiate(pc,  "RCLB.Ev.CLod", DIS_EADDR32);
50493 
50494       
50495 
50496       
50497       
50498       
50499     } 
50500     goto MATCH_finished_c; 
50501     
50502   MATCH_label_c712: (void)0; /*placeholder for label*/ 
50503     { 
50504       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50505       nextPC = 7 + MATCH_p; 
50506       
50507 #line 710 "frontend/machine/pentium/decoder.m"
50508       
50509 
50510             stmts = instantiate(pc,  "RCLB.Ev.CLod", DIS_EADDR32);
50511 
50512       
50513 
50514       
50515       
50516       
50517     } 
50518     goto MATCH_finished_c; 
50519     
50520   MATCH_label_c713: (void)0; /*placeholder for label*/ 
50521     { 
50522       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50523       nextPC = 6 + MATCH_p; 
50524       
50525 #line 710 "frontend/machine/pentium/decoder.m"
50526       
50527 
50528             stmts = instantiate(pc,  "RCLB.Ev.CLod", DIS_EADDR32);
50529 
50530       
50531 
50532       
50533       
50534       
50535     } 
50536     goto MATCH_finished_c; 
50537     
50538   MATCH_label_c714: (void)0; /*placeholder for label*/ 
50539     { 
50540       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50541       nextPC = 2 + MATCH_p; 
50542       
50543 #line 698 "frontend/machine/pentium/decoder.m"
50544       
50545 
50546             stmts = instantiate(pc,  "RCRB.Ev.CLod", DIS_EADDR32);
50547 
50548       
50549 
50550       
50551       
50552       
50553     } 
50554     goto MATCH_finished_c; 
50555     
50556   MATCH_label_c715: (void)0; /*placeholder for label*/ 
50557     { 
50558       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50559       nextPC = 3 + MATCH_p; 
50560       
50561 #line 698 "frontend/machine/pentium/decoder.m"
50562       
50563 
50564             stmts = instantiate(pc,  "RCRB.Ev.CLod", DIS_EADDR32);
50565 
50566       
50567 
50568       
50569       
50570       
50571     } 
50572     goto MATCH_finished_c; 
50573     
50574   MATCH_label_c716: (void)0; /*placeholder for label*/ 
50575     { 
50576       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50577       nextPC = 7 + MATCH_p; 
50578       
50579 #line 698 "frontend/machine/pentium/decoder.m"
50580       
50581 
50582             stmts = instantiate(pc,  "RCRB.Ev.CLod", DIS_EADDR32);
50583 
50584       
50585 
50586       
50587       
50588       
50589     } 
50590     goto MATCH_finished_c; 
50591     
50592   MATCH_label_c717: (void)0; /*placeholder for label*/ 
50593     { 
50594       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50595       nextPC = 6 + MATCH_p; 
50596       
50597 #line 698 "frontend/machine/pentium/decoder.m"
50598       
50599 
50600             stmts = instantiate(pc,  "RCRB.Ev.CLod", DIS_EADDR32);
50601 
50602       
50603 
50604       
50605       
50606       
50607     } 
50608     goto MATCH_finished_c; 
50609     
50610   MATCH_label_c718: (void)0; /*placeholder for label*/ 
50611     { 
50612       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50613       nextPC = 2 + MATCH_p; 
50614       
50615 #line 686 "frontend/machine/pentium/decoder.m"
50616       
50617 
50618             stmts = instantiate(pc,  "SHLSALB.Ev.CLod", DIS_EADDR32);
50619 
50620       
50621 
50622       
50623       
50624       
50625     } 
50626     goto MATCH_finished_c; 
50627     
50628   MATCH_label_c719: (void)0; /*placeholder for label*/ 
50629     { 
50630       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50631       nextPC = 3 + MATCH_p; 
50632       
50633 #line 686 "frontend/machine/pentium/decoder.m"
50634       
50635 
50636             stmts = instantiate(pc,  "SHLSALB.Ev.CLod", DIS_EADDR32);
50637 
50638       
50639 
50640       
50641       
50642       
50643     } 
50644     goto MATCH_finished_c; 
50645     
50646   MATCH_label_c720: (void)0; /*placeholder for label*/ 
50647     { 
50648       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50649       nextPC = 7 + MATCH_p; 
50650       
50651 #line 686 "frontend/machine/pentium/decoder.m"
50652       
50653 
50654             stmts = instantiate(pc,  "SHLSALB.Ev.CLod", DIS_EADDR32);
50655 
50656       
50657 
50658       
50659       
50660       
50661     } 
50662     goto MATCH_finished_c; 
50663     
50664   MATCH_label_c721: (void)0; /*placeholder for label*/ 
50665     { 
50666       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50667       nextPC = 6 + MATCH_p; 
50668       
50669 #line 686 "frontend/machine/pentium/decoder.m"
50670       
50671 
50672             stmts = instantiate(pc,  "SHLSALB.Ev.CLod", DIS_EADDR32);
50673 
50674       
50675 
50676       
50677       
50678       
50679     } 
50680     goto MATCH_finished_c; 
50681     
50682   MATCH_label_c722: (void)0; /*placeholder for label*/ 
50683     { 
50684       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50685       nextPC = 2 + MATCH_p; 
50686       
50687 #line 674 "frontend/machine/pentium/decoder.m"
50688       
50689 
50690             stmts = instantiate(pc,  "SHRB.Ev.CLod", DIS_EADDR32);
50691 
50692       
50693 
50694       
50695       
50696       
50697     } 
50698     goto MATCH_finished_c; 
50699     
50700   MATCH_label_c723: (void)0; /*placeholder for label*/ 
50701     { 
50702       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50703       nextPC = 3 + MATCH_p; 
50704       
50705 #line 674 "frontend/machine/pentium/decoder.m"
50706       
50707 
50708             stmts = instantiate(pc,  "SHRB.Ev.CLod", DIS_EADDR32);
50709 
50710       
50711 
50712       
50713       
50714       
50715     } 
50716     goto MATCH_finished_c; 
50717     
50718   MATCH_label_c724: (void)0; /*placeholder for label*/ 
50719     { 
50720       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50721       nextPC = 7 + MATCH_p; 
50722       
50723 #line 674 "frontend/machine/pentium/decoder.m"
50724       
50725 
50726             stmts = instantiate(pc,  "SHRB.Ev.CLod", DIS_EADDR32);
50727 
50728       
50729 
50730       
50731       
50732       
50733     } 
50734     goto MATCH_finished_c; 
50735     
50736   MATCH_label_c725: (void)0; /*placeholder for label*/ 
50737     { 
50738       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50739       nextPC = 6 + MATCH_p; 
50740       
50741 #line 674 "frontend/machine/pentium/decoder.m"
50742       
50743 
50744             stmts = instantiate(pc,  "SHRB.Ev.CLod", DIS_EADDR32);
50745 
50746       
50747 
50748       
50749       
50750       
50751     } 
50752     goto MATCH_finished_c; 
50753     
50754   MATCH_label_c726: (void)0; /*placeholder for label*/ 
50755     { 
50756       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50757       nextPC = 2 + MATCH_p; 
50758       
50759 #line 662 "frontend/machine/pentium/decoder.m"
50760       
50761 
50762             stmts = instantiate(pc,  "SARB.Ev.CLod", DIS_EADDR32);
50763 
50764       
50765 
50766       
50767       
50768       
50769     } 
50770     goto MATCH_finished_c; 
50771     
50772   MATCH_label_c727: (void)0; /*placeholder for label*/ 
50773     { 
50774       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50775       nextPC = 3 + MATCH_p; 
50776       
50777 #line 662 "frontend/machine/pentium/decoder.m"
50778       
50779 
50780             stmts = instantiate(pc,  "SARB.Ev.CLod", DIS_EADDR32);
50781 
50782       
50783 
50784       
50785       
50786       
50787     } 
50788     goto MATCH_finished_c; 
50789     
50790   MATCH_label_c728: (void)0; /*placeholder for label*/ 
50791     { 
50792       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50793       nextPC = 7 + MATCH_p; 
50794       
50795 #line 662 "frontend/machine/pentium/decoder.m"
50796       
50797 
50798             stmts = instantiate(pc,  "SARB.Ev.CLod", DIS_EADDR32);
50799 
50800       
50801 
50802       
50803       
50804       
50805     } 
50806     goto MATCH_finished_c; 
50807     
50808   MATCH_label_c729: (void)0; /*placeholder for label*/ 
50809     { 
50810       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50811       nextPC = 6 + MATCH_p; 
50812       
50813 #line 662 "frontend/machine/pentium/decoder.m"
50814       
50815 
50816             stmts = instantiate(pc,  "SARB.Ev.CLod", DIS_EADDR32);
50817 
50818       
50819 
50820       
50821       
50822       
50823     } 
50824     goto MATCH_finished_c; 
50825     
50826   MATCH_label_c730: (void)0; /*placeholder for label*/ 
50827     { 
50828       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50829       unsigned i8 = (MATCH_w_8_16 & 0xff) /* i8 at 16 */;
50830       nextPC = 3 + MATCH_p; 
50831       
50832 #line 393 "frontend/machine/pentium/decoder.m"
50833       
50834 
50835             stmts = instantiate(pc,  "TEST.Eb.Ib", DIS_EADDR8, DIS_I8);
50836 
50837       
50838 
50839       
50840       
50841       
50842     } 
50843     goto MATCH_finished_c; 
50844     
50845   MATCH_label_c731: (void)0; /*placeholder for label*/ 
50846     { 
50847       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50848       unsigned i8 = (MATCH_w_8_24 & 0xff) /* i8 at 24 */;
50849       nextPC = 4 + MATCH_p; 
50850       
50851 #line 393 "frontend/machine/pentium/decoder.m"
50852       
50853 
50854             stmts = instantiate(pc,  "TEST.Eb.Ib", DIS_EADDR8, DIS_I8);
50855 
50856       
50857 
50858       
50859       
50860       
50861     } 
50862     goto MATCH_finished_c; 
50863     
50864   MATCH_label_c732: (void)0; /*placeholder for label*/ 
50865     { 
50866       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50867       unsigned i8 = (MATCH_w_8_56 & 0xff) /* i8 at 56 */;
50868       nextPC = 8 + MATCH_p; 
50869       
50870 #line 393 "frontend/machine/pentium/decoder.m"
50871       
50872 
50873             stmts = instantiate(pc,  "TEST.Eb.Ib", DIS_EADDR8, DIS_I8);
50874 
50875       
50876 
50877       
50878       
50879       
50880     } 
50881     goto MATCH_finished_c; 
50882     
50883   MATCH_label_c733: (void)0; /*placeholder for label*/ 
50884     { 
50885       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50886       unsigned i8 = (MATCH_w_8_48 & 0xff) /* i8 at 48 */;
50887       nextPC = 7 + MATCH_p; 
50888       
50889 #line 393 "frontend/machine/pentium/decoder.m"
50890       
50891 
50892             stmts = instantiate(pc,  "TEST.Eb.Ib", DIS_EADDR8, DIS_I8);
50893 
50894       
50895 
50896       
50897       
50898       
50899     } 
50900     goto MATCH_finished_c; 
50901     
50902   MATCH_label_c734: (void)0; /*placeholder for label*/ 
50903     { 
50904       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50905       nextPC = 2 + MATCH_p; 
50906       
50907 #line 916 "frontend/machine/pentium/decoder.m"
50908       
50909 
50910             stmts = instantiate(pc,  "NOTb", DIS_EADDR8);
50911 
50912       
50913 
50914       
50915       
50916       
50917     } 
50918     goto MATCH_finished_c; 
50919     
50920   MATCH_label_c735: (void)0; /*placeholder for label*/ 
50921     { 
50922       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50923       nextPC = 3 + MATCH_p; 
50924       
50925 #line 916 "frontend/machine/pentium/decoder.m"
50926       
50927 
50928             stmts = instantiate(pc,  "NOTb", DIS_EADDR8);
50929 
50930       
50931 
50932       
50933       
50934       
50935     } 
50936     goto MATCH_finished_c; 
50937     
50938   MATCH_label_c736: (void)0; /*placeholder for label*/ 
50939     { 
50940       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50941       nextPC = 7 + MATCH_p; 
50942       
50943 #line 916 "frontend/machine/pentium/decoder.m"
50944       
50945 
50946             stmts = instantiate(pc,  "NOTb", DIS_EADDR8);
50947 
50948       
50949 
50950       
50951       
50952       
50953     } 
50954     goto MATCH_finished_c; 
50955     
50956   MATCH_label_c737: (void)0; /*placeholder for label*/ 
50957     { 
50958       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50959       nextPC = 6 + MATCH_p; 
50960       
50961 #line 916 "frontend/machine/pentium/decoder.m"
50962       
50963 
50964             stmts = instantiate(pc,  "NOTb", DIS_EADDR8);
50965 
50966       
50967 
50968       
50969       
50970       
50971     } 
50972     goto MATCH_finished_c; 
50973     
50974   MATCH_label_c738: (void)0; /*placeholder for label*/ 
50975     { 
50976       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50977       nextPC = 2 + MATCH_p; 
50978       
50979 #line 925 "frontend/machine/pentium/decoder.m"
50980       
50981 
50982             stmts = instantiate(pc,  "NEGb", DIS_EADDR8);
50983 
50984       
50985 
50986       
50987       
50988       
50989     } 
50990     goto MATCH_finished_c; 
50991     
50992   MATCH_label_c739: (void)0; /*placeholder for label*/ 
50993     { 
50994       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50995       nextPC = 3 + MATCH_p; 
50996       
50997 #line 925 "frontend/machine/pentium/decoder.m"
50998       
50999 
51000             stmts = instantiate(pc,  "NEGb", DIS_EADDR8);
51001 
51002       
51003 
51004       
51005       
51006       
51007     } 
51008     goto MATCH_finished_c; 
51009     
51010   MATCH_label_c740: (void)0; /*placeholder for label*/ 
51011     { 
51012       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51013       nextPC = 7 + MATCH_p; 
51014       
51015 #line 925 "frontend/machine/pentium/decoder.m"
51016       
51017 
51018             stmts = instantiate(pc,  "NEGb", DIS_EADDR8);
51019 
51020       
51021 
51022       
51023       
51024       
51025     } 
51026     goto MATCH_finished_c; 
51027     
51028   MATCH_label_c741: (void)0; /*placeholder for label*/ 
51029     { 
51030       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51031       nextPC = 6 + MATCH_p; 
51032       
51033 #line 925 "frontend/machine/pentium/decoder.m"
51034       
51035 
51036             stmts = instantiate(pc,  "NEGb", DIS_EADDR8);
51037 
51038       
51039 
51040       
51041       
51042       
51043     } 
51044     goto MATCH_finished_c; 
51045     
51046   MATCH_label_c742: (void)0; /*placeholder for label*/ 
51047     { 
51048       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51049       nextPC = 2 + MATCH_p; 
51050       
51051 #line 934 "frontend/machine/pentium/decoder.m"
51052       
51053 
51054             stmts = instantiate(pc,  "MUL.AL", DIS_EADDR8);
51055 
51056       
51057 
51058       
51059       
51060       
51061     } 
51062     goto MATCH_finished_c; 
51063     
51064   MATCH_label_c743: (void)0; /*placeholder for label*/ 
51065     { 
51066       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51067       nextPC = 3 + MATCH_p; 
51068       
51069 #line 934 "frontend/machine/pentium/decoder.m"
51070       
51071 
51072             stmts = instantiate(pc,  "MUL.AL", DIS_EADDR8);
51073 
51074       
51075 
51076       
51077       
51078       
51079     } 
51080     goto MATCH_finished_c; 
51081     
51082   MATCH_label_c744: (void)0; /*placeholder for label*/ 
51083     { 
51084       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51085       nextPC = 7 + MATCH_p; 
51086       
51087 #line 934 "frontend/machine/pentium/decoder.m"
51088       
51089 
51090             stmts = instantiate(pc,  "MUL.AL", DIS_EADDR8);
51091 
51092       
51093 
51094       
51095       
51096       
51097     } 
51098     goto MATCH_finished_c; 
51099     
51100   MATCH_label_c745: (void)0; /*placeholder for label*/ 
51101     { 
51102       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51103       nextPC = 6 + MATCH_p; 
51104       
51105 #line 934 "frontend/machine/pentium/decoder.m"
51106       
51107 
51108             stmts = instantiate(pc,  "MUL.AL", DIS_EADDR8);
51109 
51110       
51111 
51112       
51113       
51114       
51115     } 
51116     goto MATCH_finished_c; 
51117     
51118   MATCH_label_c746: (void)0; /*placeholder for label*/ 
51119     { 
51120       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51121       nextPC = 2 + MATCH_p; 
51122       
51123 #line 1178 "frontend/machine/pentium/decoder.m"
51124       
51125 
51126             stmts = instantiate(pc,  "IMULb", DIS_EADDR8);
51127 
51128       
51129 
51130       
51131       
51132       
51133     } 
51134     goto MATCH_finished_c; 
51135     
51136   MATCH_label_c747: (void)0; /*placeholder for label*/ 
51137     { 
51138       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51139       nextPC = 3 + MATCH_p; 
51140       
51141 #line 1178 "frontend/machine/pentium/decoder.m"
51142       
51143 
51144             stmts = instantiate(pc,  "IMULb", DIS_EADDR8);
51145 
51146       
51147 
51148       
51149       
51150       
51151     } 
51152     goto MATCH_finished_c; 
51153     
51154   MATCH_label_c748: (void)0; /*placeholder for label*/ 
51155     { 
51156       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51157       nextPC = 7 + MATCH_p; 
51158       
51159 #line 1178 "frontend/machine/pentium/decoder.m"
51160       
51161 
51162             stmts = instantiate(pc,  "IMULb", DIS_EADDR8);
51163 
51164       
51165 
51166       
51167       
51168       
51169     } 
51170     goto MATCH_finished_c; 
51171     
51172   MATCH_label_c749: (void)0; /*placeholder for label*/ 
51173     { 
51174       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51175       nextPC = 6 + MATCH_p; 
51176       
51177 #line 1178 "frontend/machine/pentium/decoder.m"
51178       
51179 
51180             stmts = instantiate(pc,  "IMULb", DIS_EADDR8);
51181 
51182       
51183 
51184       
51185       
51186       
51187     } 
51188     goto MATCH_finished_c; 
51189     
51190   MATCH_label_c750: (void)0; /*placeholder for label*/ 
51191     { 
51192       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51193       nextPC = 2 + MATCH_p; 
51194       
51195 #line 1202 "frontend/machine/pentium/decoder.m"
51196       
51197 
51198             stmts = instantiate(pc,  "DIVAL", DIS_EADDR8);
51199 
51200       
51201 
51202       
51203       
51204       
51205     } 
51206     goto MATCH_finished_c; 
51207     
51208   MATCH_label_c751: (void)0; /*placeholder for label*/ 
51209     { 
51210       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51211       nextPC = 3 + MATCH_p; 
51212       
51213 #line 1202 "frontend/machine/pentium/decoder.m"
51214       
51215 
51216             stmts = instantiate(pc,  "DIVAL", DIS_EADDR8);
51217 
51218       
51219 
51220       
51221       
51222       
51223     } 
51224     goto MATCH_finished_c; 
51225     
51226   MATCH_label_c752: (void)0; /*placeholder for label*/ 
51227     { 
51228       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51229       nextPC = 7 + MATCH_p; 
51230       
51231 #line 1202 "frontend/machine/pentium/decoder.m"
51232       
51233 
51234             stmts = instantiate(pc,  "DIVAL", DIS_EADDR8);
51235 
51236       
51237 
51238       
51239       
51240       
51241     } 
51242     goto MATCH_finished_c; 
51243     
51244   MATCH_label_c753: (void)0; /*placeholder for label*/ 
51245     { 
51246       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51247       nextPC = 6 + MATCH_p; 
51248       
51249 #line 1202 "frontend/machine/pentium/decoder.m"
51250       
51251 
51252             stmts = instantiate(pc,  "DIVAL", DIS_EADDR8);
51253 
51254       
51255 
51256       
51257       
51258       
51259     } 
51260     goto MATCH_finished_c; 
51261     
51262   MATCH_label_c754: (void)0; /*placeholder for label*/ 
51263     { 
51264       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51265       nextPC = 2 + MATCH_p; 
51266       
51267 #line 1187 "frontend/machine/pentium/decoder.m"
51268       
51269 
51270             stmts = instantiate(pc,  "IDIV", DIS_EADDR8); /* ?? */
51271 
51272       
51273 
51274       //    | HLT() =>
51275 
51276       //        stmts = instantiate(pc,  "HLT");
51277 
51278       
51279 
51280       
51281       
51282       
51283     } 
51284     goto MATCH_finished_c; 
51285     
51286   MATCH_label_c755: (void)0; /*placeholder for label*/ 
51287     { 
51288       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51289       nextPC = 3 + MATCH_p; 
51290       
51291 #line 1187 "frontend/machine/pentium/decoder.m"
51292       
51293 
51294             stmts = instantiate(pc,  "IDIV", DIS_EADDR8); /* ?? */
51295 
51296       
51297 
51298       //    | HLT() =>
51299 
51300       //        stmts = instantiate(pc,  "HLT");
51301 
51302       
51303 
51304       
51305       
51306       
51307     } 
51308     goto MATCH_finished_c; 
51309     
51310   MATCH_label_c756: (void)0; /*placeholder for label*/ 
51311     { 
51312       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51313       nextPC = 7 + MATCH_p; 
51314       
51315 #line 1187 "frontend/machine/pentium/decoder.m"
51316       
51317 
51318             stmts = instantiate(pc,  "IDIV", DIS_EADDR8); /* ?? */
51319 
51320       
51321 
51322       //    | HLT() =>
51323 
51324       //        stmts = instantiate(pc,  "HLT");
51325 
51326       
51327 
51328       
51329       
51330       
51331     } 
51332     goto MATCH_finished_c; 
51333     
51334   MATCH_label_c757: (void)0; /*placeholder for label*/ 
51335     { 
51336       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51337       nextPC = 6 + MATCH_p; 
51338       
51339 #line 1187 "frontend/machine/pentium/decoder.m"
51340       
51341 
51342             stmts = instantiate(pc,  "IDIV", DIS_EADDR8); /* ?? */
51343 
51344       
51345 
51346       //    | HLT() =>
51347 
51348       //        stmts = instantiate(pc,  "HLT");
51349 
51350       
51351 
51352       
51353       
51354       
51355     } 
51356     goto MATCH_finished_c; 
51357     
51358   MATCH_label_c758: (void)0; /*placeholder for label*/ 
51359     { 
51360       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51361       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
51362       nextPC = 6 + MATCH_p; 
51363       
51364 #line 387 "frontend/machine/pentium/decoder.m"
51365       
51366 
51367             stmts = instantiate(pc,  "TEST.Ed.Id", DIS_EADDR32, DIS_I32);
51368 
51369       
51370 
51371       
51372       
51373       
51374     } 
51375     goto MATCH_finished_c; 
51376     
51377   MATCH_label_c759: (void)0; /*placeholder for label*/ 
51378     { 
51379       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51380       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
51381       nextPC = 7 + MATCH_p; 
51382       
51383 #line 387 "frontend/machine/pentium/decoder.m"
51384       
51385 
51386             stmts = instantiate(pc,  "TEST.Ed.Id", DIS_EADDR32, DIS_I32);
51387 
51388       
51389 
51390       
51391       
51392       
51393     } 
51394     goto MATCH_finished_c; 
51395     
51396   MATCH_label_c760: (void)0; /*placeholder for label*/ 
51397     { 
51398       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51399       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
51400       nextPC = 11 + MATCH_p; 
51401       
51402 #line 387 "frontend/machine/pentium/decoder.m"
51403       
51404 
51405             stmts = instantiate(pc,  "TEST.Ed.Id", DIS_EADDR32, DIS_I32);
51406 
51407       
51408 
51409       
51410       
51411       
51412     } 
51413     goto MATCH_finished_c; 
51414     
51415   MATCH_label_c761: (void)0; /*placeholder for label*/ 
51416     { 
51417       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51418       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
51419       nextPC = 10 + MATCH_p; 
51420       
51421 #line 387 "frontend/machine/pentium/decoder.m"
51422       
51423 
51424             stmts = instantiate(pc,  "TEST.Ed.Id", DIS_EADDR32, DIS_I32);
51425 
51426       
51427 
51428       
51429       
51430       
51431     } 
51432     goto MATCH_finished_c; 
51433     
51434   MATCH_label_c762: (void)0; /*placeholder for label*/ 
51435     { 
51436       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51437       nextPC = 2 + MATCH_p; 
51438       
51439 #line 910 "frontend/machine/pentium/decoder.m"
51440       
51441 
51442             stmts = instantiate(pc,  "NOTod", DIS_EADDR32);
51443 
51444       
51445 
51446       
51447       
51448       
51449     } 
51450     goto MATCH_finished_c; 
51451     
51452   MATCH_label_c763: (void)0; /*placeholder for label*/ 
51453     { 
51454       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51455       nextPC = 3 + MATCH_p; 
51456       
51457 #line 910 "frontend/machine/pentium/decoder.m"
51458       
51459 
51460             stmts = instantiate(pc,  "NOTod", DIS_EADDR32);
51461 
51462       
51463 
51464       
51465       
51466       
51467     } 
51468     goto MATCH_finished_c; 
51469     
51470   MATCH_label_c764: (void)0; /*placeholder for label*/ 
51471     { 
51472       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51473       nextPC = 7 + MATCH_p; 
51474       
51475 #line 910 "frontend/machine/pentium/decoder.m"
51476       
51477 
51478             stmts = instantiate(pc,  "NOTod", DIS_EADDR32);
51479 
51480       
51481 
51482       
51483       
51484       
51485     } 
51486     goto MATCH_finished_c; 
51487     
51488   MATCH_label_c765: (void)0; /*placeholder for label*/ 
51489     { 
51490       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51491       nextPC = 6 + MATCH_p; 
51492       
51493 #line 910 "frontend/machine/pentium/decoder.m"
51494       
51495 
51496             stmts = instantiate(pc,  "NOTod", DIS_EADDR32);
51497 
51498       
51499 
51500       
51501       
51502       
51503     } 
51504     goto MATCH_finished_c; 
51505     
51506   MATCH_label_c766: (void)0; /*placeholder for label*/ 
51507     { 
51508       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51509       nextPC = 2 + MATCH_p; 
51510       
51511 #line 919 "frontend/machine/pentium/decoder.m"
51512       
51513 
51514             stmts = instantiate(pc,  "NEGod", DIS_EADDR32);
51515 
51516       
51517 
51518       
51519       
51520       
51521     } 
51522     goto MATCH_finished_c; 
51523     
51524   MATCH_label_c767: (void)0; /*placeholder for label*/ 
51525     { 
51526       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51527       nextPC = 3 + MATCH_p; 
51528       
51529 #line 919 "frontend/machine/pentium/decoder.m"
51530       
51531 
51532             stmts = instantiate(pc,  "NEGod", DIS_EADDR32);
51533 
51534       
51535 
51536       
51537       
51538       
51539     } 
51540     goto MATCH_finished_c; 
51541     
51542   MATCH_label_c768: (void)0; /*placeholder for label*/ 
51543     { 
51544       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51545       nextPC = 7 + MATCH_p; 
51546       
51547 #line 919 "frontend/machine/pentium/decoder.m"
51548       
51549 
51550             stmts = instantiate(pc,  "NEGod", DIS_EADDR32);
51551 
51552       
51553 
51554       
51555       
51556       
51557     } 
51558     goto MATCH_finished_c; 
51559     
51560   MATCH_label_c769: (void)0; /*placeholder for label*/ 
51561     { 
51562       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51563       nextPC = 6 + MATCH_p; 
51564       
51565 #line 919 "frontend/machine/pentium/decoder.m"
51566       
51567 
51568             stmts = instantiate(pc,  "NEGod", DIS_EADDR32);
51569 
51570       
51571 
51572       
51573       
51574       
51575     } 
51576     goto MATCH_finished_c; 
51577     
51578   MATCH_label_c770: (void)0; /*placeholder for label*/ 
51579     { 
51580       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51581       nextPC = 2 + MATCH_p; 
51582       
51583 #line 928 "frontend/machine/pentium/decoder.m"
51584       
51585 
51586             stmts = instantiate(pc,  "MUL.AXod", DIS_EADDR32);
51587 
51588       
51589 
51590       
51591       
51592       
51593     } 
51594     goto MATCH_finished_c; 
51595     
51596   MATCH_label_c771: (void)0; /*placeholder for label*/ 
51597     { 
51598       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51599       nextPC = 3 + MATCH_p; 
51600       
51601 #line 928 "frontend/machine/pentium/decoder.m"
51602       
51603 
51604             stmts = instantiate(pc,  "MUL.AXod", DIS_EADDR32);
51605 
51606       
51607 
51608       
51609       
51610       
51611     } 
51612     goto MATCH_finished_c; 
51613     
51614   MATCH_label_c772: (void)0; /*placeholder for label*/ 
51615     { 
51616       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51617       nextPC = 7 + MATCH_p; 
51618       
51619 #line 928 "frontend/machine/pentium/decoder.m"
51620       
51621 
51622             stmts = instantiate(pc,  "MUL.AXod", DIS_EADDR32);
51623 
51624       
51625 
51626       
51627       
51628       
51629     } 
51630     goto MATCH_finished_c; 
51631     
51632   MATCH_label_c773: (void)0; /*placeholder for label*/ 
51633     { 
51634       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51635       nextPC = 6 + MATCH_p; 
51636       
51637 #line 928 "frontend/machine/pentium/decoder.m"
51638       
51639 
51640             stmts = instantiate(pc,  "MUL.AXod", DIS_EADDR32);
51641 
51642       
51643 
51644       
51645       
51646       
51647     } 
51648     goto MATCH_finished_c; 
51649     
51650   MATCH_label_c774: (void)0; /*placeholder for label*/ 
51651     { 
51652       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51653       nextPC = 2 + MATCH_p; 
51654       
51655 #line 1172 "frontend/machine/pentium/decoder.m"
51656       
51657 
51658             stmts = instantiate(pc,  "IMULod", DIS_EADDR32);
51659 
51660       
51661 
51662       
51663       
51664       
51665     } 
51666     goto MATCH_finished_c; 
51667     
51668   MATCH_label_c775: (void)0; /*placeholder for label*/ 
51669     { 
51670       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51671       nextPC = 3 + MATCH_p; 
51672       
51673 #line 1172 "frontend/machine/pentium/decoder.m"
51674       
51675 
51676             stmts = instantiate(pc,  "IMULod", DIS_EADDR32);
51677 
51678       
51679 
51680       
51681       
51682       
51683     } 
51684     goto MATCH_finished_c; 
51685     
51686   MATCH_label_c776: (void)0; /*placeholder for label*/ 
51687     { 
51688       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51689       nextPC = 7 + MATCH_p; 
51690       
51691 #line 1172 "frontend/machine/pentium/decoder.m"
51692       
51693 
51694             stmts = instantiate(pc,  "IMULod", DIS_EADDR32);
51695 
51696       
51697 
51698       
51699       
51700       
51701     } 
51702     goto MATCH_finished_c; 
51703     
51704   MATCH_label_c777: (void)0; /*placeholder for label*/ 
51705     { 
51706       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51707       nextPC = 6 + MATCH_p; 
51708       
51709 #line 1172 "frontend/machine/pentium/decoder.m"
51710       
51711 
51712             stmts = instantiate(pc,  "IMULod", DIS_EADDR32);
51713 
51714       
51715 
51716       
51717       
51718       
51719     } 
51720     goto MATCH_finished_c; 
51721     
51722   MATCH_label_c778: (void)0; /*placeholder for label*/ 
51723     { 
51724       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51725       nextPC = 2 + MATCH_p; 
51726       
51727 #line 1196 "frontend/machine/pentium/decoder.m"
51728       
51729 
51730             stmts = instantiate(pc,  "DIVeAX", DIS_EADDR32);
51731 
51732       
51733 
51734       
51735       
51736       
51737     } 
51738     goto MATCH_finished_c; 
51739     
51740   MATCH_label_c779: (void)0; /*placeholder for label*/ 
51741     { 
51742       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51743       nextPC = 3 + MATCH_p; 
51744       
51745 #line 1196 "frontend/machine/pentium/decoder.m"
51746       
51747 
51748             stmts = instantiate(pc,  "DIVeAX", DIS_EADDR32);
51749 
51750       
51751 
51752       
51753       
51754       
51755     } 
51756     goto MATCH_finished_c; 
51757     
51758   MATCH_label_c780: (void)0; /*placeholder for label*/ 
51759     { 
51760       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51761       nextPC = 7 + MATCH_p; 
51762       
51763 #line 1196 "frontend/machine/pentium/decoder.m"
51764       
51765 
51766             stmts = instantiate(pc,  "DIVeAX", DIS_EADDR32);
51767 
51768       
51769 
51770       
51771       
51772       
51773     } 
51774     goto MATCH_finished_c; 
51775     
51776   MATCH_label_c781: (void)0; /*placeholder for label*/ 
51777     { 
51778       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51779       nextPC = 6 + MATCH_p; 
51780       
51781 #line 1196 "frontend/machine/pentium/decoder.m"
51782       
51783 
51784             stmts = instantiate(pc,  "DIVeAX", DIS_EADDR32);
51785 
51786       
51787 
51788       
51789       
51790       
51791     } 
51792     goto MATCH_finished_c; 
51793     
51794   MATCH_label_c782: (void)0; /*placeholder for label*/ 
51795     { 
51796       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51797       nextPC = 2 + MATCH_p; 
51798       
51799 #line 1181 "frontend/machine/pentium/decoder.m"
51800       
51801 
51802             stmts = instantiate(pc,  "IDIVeAX", DIS_EADDR32);
51803 
51804       
51805 
51806       
51807       
51808       
51809     } 
51810     goto MATCH_finished_c; 
51811     
51812   MATCH_label_c783: (void)0; /*placeholder for label*/ 
51813     { 
51814       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51815       nextPC = 3 + MATCH_p; 
51816       
51817 #line 1181 "frontend/machine/pentium/decoder.m"
51818       
51819 
51820             stmts = instantiate(pc,  "IDIVeAX", DIS_EADDR32);
51821 
51822       
51823 
51824       
51825       
51826       
51827     } 
51828     goto MATCH_finished_c; 
51829     
51830   MATCH_label_c784: (void)0; /*placeholder for label*/ 
51831     { 
51832       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51833       nextPC = 7 + MATCH_p; 
51834       
51835 #line 1181 "frontend/machine/pentium/decoder.m"
51836       
51837 
51838             stmts = instantiate(pc,  "IDIVeAX", DIS_EADDR32);
51839 
51840       
51841 
51842       
51843       
51844       
51845     } 
51846     goto MATCH_finished_c; 
51847     
51848   MATCH_label_c785: (void)0; /*placeholder for label*/ 
51849     { 
51850       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51851       nextPC = 6 + MATCH_p; 
51852       
51853 #line 1181 "frontend/machine/pentium/decoder.m"
51854       
51855 
51856             stmts = instantiate(pc,  "IDIVeAX", DIS_EADDR32);
51857 
51858       
51859 
51860       
51861       
51862       
51863     } 
51864     goto MATCH_finished_c; 
51865     
51866   MATCH_label_c786: (void)0; /*placeholder for label*/ 
51867     { 
51868       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51869       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
51870       nextPC = 2 + MATCH_p; 
51871       
51872 #line 1543 "frontend/machine/pentium/decoder.m"
51873       
51874 
51875             stmts = instantiate(pc,  "ORmrb", DIS_EADDR8, DIS_R8);
51876 
51877       
51878 
51879       
51880       
51881       
51882     } 
51883     goto MATCH_finished_c; 
51884     
51885   MATCH_label_c787: (void)0; /*placeholder for label*/ 
51886     { 
51887       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51888       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
51889       nextPC = 3 + MATCH_p; 
51890       
51891 #line 1543 "frontend/machine/pentium/decoder.m"
51892       
51893 
51894             stmts = instantiate(pc,  "ORmrb", DIS_EADDR8, DIS_R8);
51895 
51896       
51897 
51898       
51899       
51900       
51901     } 
51902     goto MATCH_finished_c; 
51903     
51904   MATCH_label_c788: (void)0; /*placeholder for label*/ 
51905     { 
51906       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51907       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
51908       nextPC = 7 + MATCH_p; 
51909       
51910 #line 1543 "frontend/machine/pentium/decoder.m"
51911       
51912 
51913             stmts = instantiate(pc,  "ORmrb", DIS_EADDR8, DIS_R8);
51914 
51915       
51916 
51917       
51918       
51919       
51920     } 
51921     goto MATCH_finished_c; 
51922     
51923   MATCH_label_c789: (void)0; /*placeholder for label*/ 
51924     { 
51925       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51926       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
51927       nextPC = 6 + MATCH_p; 
51928       
51929 #line 1543 "frontend/machine/pentium/decoder.m"
51930       
51931 
51932             stmts = instantiate(pc,  "ORmrb", DIS_EADDR8, DIS_R8);
51933 
51934       
51935 
51936       
51937       
51938       
51939     } 
51940     goto MATCH_finished_c; 
51941     
51942   MATCH_label_c790: (void)0; /*placeholder for label*/ 
51943     { 
51944       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51945       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
51946       nextPC = 2 + MATCH_p; 
51947       
51948 #line 1513 "frontend/machine/pentium/decoder.m"
51949       
51950 
51951             stmts = instantiate(pc,  "ORmrod", DIS_EADDR32, DIS_REG32);
51952 
51953       
51954 
51955       
51956       
51957       
51958     } 
51959     goto MATCH_finished_c; 
51960     
51961   MATCH_label_c791: (void)0; /*placeholder for label*/ 
51962     { 
51963       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51964       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
51965       nextPC = 3 + MATCH_p; 
51966       
51967 #line 1513 "frontend/machine/pentium/decoder.m"
51968       
51969 
51970             stmts = instantiate(pc,  "ORmrod", DIS_EADDR32, DIS_REG32);
51971 
51972       
51973 
51974       
51975       
51976       
51977     } 
51978     goto MATCH_finished_c; 
51979     
51980   MATCH_label_c792: (void)0; /*placeholder for label*/ 
51981     { 
51982       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51983       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
51984       nextPC = 7 + MATCH_p; 
51985       
51986 #line 1513 "frontend/machine/pentium/decoder.m"
51987       
51988 
51989             stmts = instantiate(pc,  "ORmrod", DIS_EADDR32, DIS_REG32);
51990 
51991       
51992 
51993       
51994       
51995       
51996     } 
51997     goto MATCH_finished_c; 
51998     
51999   MATCH_label_c793: (void)0; /*placeholder for label*/ 
52000     { 
52001       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52002       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
52003       nextPC = 6 + MATCH_p; 
52004       
52005 #line 1513 "frontend/machine/pentium/decoder.m"
52006       
52007 
52008             stmts = instantiate(pc,  "ORmrod", DIS_EADDR32, DIS_REG32);
52009 
52010       
52011 
52012       
52013       
52014       
52015     } 
52016     goto MATCH_finished_c; 
52017     
52018   MATCH_label_c794: (void)0; /*placeholder for label*/ 
52019     { 
52020       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52021       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
52022       nextPC = 2 + MATCH_p; 
52023       
52024 #line 1471 "frontend/machine/pentium/decoder.m"
52025       
52026 
52027             stmts = instantiate(pc,  "ORrmb", DIS_R8, DIS_EADDR8);
52028 
52029       
52030 
52031       
52032       
52033       
52034     } 
52035     goto MATCH_finished_c; 
52036     
52037   MATCH_label_c795: (void)0; /*placeholder for label*/ 
52038     { 
52039       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52040       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
52041       nextPC = 3 + MATCH_p; 
52042       
52043 #line 1471 "frontend/machine/pentium/decoder.m"
52044       
52045 
52046             stmts = instantiate(pc,  "ORrmb", DIS_R8, DIS_EADDR8);
52047 
52048       
52049 
52050       
52051       
52052       
52053     } 
52054     goto MATCH_finished_c; 
52055     
52056   MATCH_label_c796: (void)0; /*placeholder for label*/ 
52057     { 
52058       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52059       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
52060       nextPC = 7 + MATCH_p; 
52061       
52062 #line 1471 "frontend/machine/pentium/decoder.m"
52063       
52064 
52065             stmts = instantiate(pc,  "ORrmb", DIS_R8, DIS_EADDR8);
52066 
52067       
52068 
52069       
52070       
52071       
52072     } 
52073     goto MATCH_finished_c; 
52074     
52075   MATCH_label_c797: (void)0; /*placeholder for label*/ 
52076     { 
52077       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52078       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
52079       nextPC = 6 + MATCH_p; 
52080       
52081 #line 1471 "frontend/machine/pentium/decoder.m"
52082       
52083 
52084             stmts = instantiate(pc,  "ORrmb", DIS_R8, DIS_EADDR8);
52085 
52086       
52087 
52088       
52089       
52090       
52091     } 
52092     goto MATCH_finished_c; 
52093     
52094   MATCH_label_c798: (void)0; /*placeholder for label*/ 
52095     { 
52096       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52097       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
52098       nextPC = 2 + MATCH_p; 
52099       
52100 #line 1441 "frontend/machine/pentium/decoder.m"
52101       
52102 
52103             stmts = instantiate(pc,  "ORrmod", DIS_REG32, DIS_EADDR32);
52104 
52105       
52106 
52107       
52108       
52109       
52110     } 
52111     goto MATCH_finished_c; 
52112     
52113   MATCH_label_c799: (void)0; /*placeholder for label*/ 
52114     { 
52115       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52116       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
52117       nextPC = 3 + MATCH_p; 
52118       
52119 #line 1441 "frontend/machine/pentium/decoder.m"
52120       
52121 
52122             stmts = instantiate(pc,  "ORrmod", DIS_REG32, DIS_EADDR32);
52123 
52124       
52125 
52126       
52127       
52128       
52129     } 
52130     goto MATCH_finished_c; 
52131     
52132   MATCH_label_c800: (void)0; /*placeholder for label*/ 
52133     { 
52134       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52135       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
52136       nextPC = 7 + MATCH_p; 
52137       
52138 #line 1441 "frontend/machine/pentium/decoder.m"
52139       
52140 
52141             stmts = instantiate(pc,  "ORrmod", DIS_REG32, DIS_EADDR32);
52142 
52143       
52144 
52145       
52146       
52147       
52148     } 
52149     goto MATCH_finished_c; 
52150     
52151   MATCH_label_c801: (void)0; /*placeholder for label*/ 
52152     { 
52153       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52154       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
52155       nextPC = 6 + MATCH_p; 
52156       
52157 #line 1441 "frontend/machine/pentium/decoder.m"
52158       
52159 
52160             stmts = instantiate(pc,  "ORrmod", DIS_REG32, DIS_EADDR32);
52161 
52162       
52163 
52164       
52165       
52166       
52167     } 
52168     goto MATCH_finished_c; 
52169     
52170   MATCH_label_c802: (void)0; /*placeholder for label*/ 
52171     { 
52172       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52173       nextPC = 3 + MATCH_p; 
52174       
52175 #line 429 "frontend/machine/pentium/decoder.m"
52176       
52177 
52178             stmts = instantiate(pc,  "SLDT", DIS_EADDR32);
52179 
52180       
52181 
52182       
52183       
52184       
52185     } 
52186     goto MATCH_finished_c; 
52187     
52188   MATCH_label_c803: (void)0; /*placeholder for label*/ 
52189     { 
52190       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52191       nextPC = 4 + MATCH_p; 
52192       
52193 #line 429 "frontend/machine/pentium/decoder.m"
52194       
52195 
52196             stmts = instantiate(pc,  "SLDT", DIS_EADDR32);
52197 
52198       
52199 
52200       
52201       
52202       
52203     } 
52204     goto MATCH_finished_c; 
52205     
52206   MATCH_label_c804: (void)0; /*placeholder for label*/ 
52207     { 
52208       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52209       nextPC = 8 + MATCH_p; 
52210       
52211 #line 429 "frontend/machine/pentium/decoder.m"
52212       
52213 
52214             stmts = instantiate(pc,  "SLDT", DIS_EADDR32);
52215 
52216       
52217 
52218       
52219       
52220       
52221     } 
52222     goto MATCH_finished_c; 
52223     
52224   MATCH_label_c805: (void)0; /*placeholder for label*/ 
52225     { 
52226       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52227       nextPC = 7 + MATCH_p; 
52228       
52229 #line 429 "frontend/machine/pentium/decoder.m"
52230       
52231 
52232             stmts = instantiate(pc,  "SLDT", DIS_EADDR32);
52233 
52234       
52235 
52236       
52237       
52238       
52239     } 
52240     goto MATCH_finished_c; 
52241     
52242   MATCH_label_c806: (void)0; /*placeholder for label*/ 
52243     { 
52244       unsigned Mem = 2 + addressToPC(MATCH_p);
52245       nextPC = 4 + MATCH_p; 
52246       
52247 #line 405 "frontend/machine/pentium/decoder.m"
52248       
52249 
52250             stmts = instantiate(pc,  "STR", DIS_MEM);
52251 
52252       
52253 
52254       
52255       
52256       
52257     } 
52258     goto MATCH_finished_c; 
52259     
52260   MATCH_label_c807: (void)0; /*placeholder for label*/ 
52261     { 
52262       unsigned Mem = 2 + addressToPC(MATCH_p);
52263       nextPC = 8 + MATCH_p; 
52264       
52265 #line 405 "frontend/machine/pentium/decoder.m"
52266       
52267 
52268             stmts = instantiate(pc,  "STR", DIS_MEM);
52269 
52270       
52271 
52272       
52273       
52274       
52275     } 
52276     goto MATCH_finished_c; 
52277     
52278   MATCH_label_c808: (void)0; /*placeholder for label*/ 
52279     { 
52280       unsigned Mem = 2 + addressToPC(MATCH_p);
52281       nextPC = 7 + MATCH_p; 
52282       
52283 #line 405 "frontend/machine/pentium/decoder.m"
52284       
52285 
52286             stmts = instantiate(pc,  "STR", DIS_MEM);
52287 
52288       
52289 
52290       
52291       
52292       
52293     } 
52294     goto MATCH_finished_c; 
52295     
52296   MATCH_label_c809: (void)0; /*placeholder for label*/ 
52297     { 
52298       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52299       nextPC = 3 + MATCH_p; 
52300       
52301 #line 1040 "frontend/machine/pentium/decoder.m"
52302       
52303 
52304             stmts = instantiate(pc,  "LTR", DIS_EADDR32);
52305 
52306       
52307 
52308       
52309       
52310       
52311     } 
52312     goto MATCH_finished_c; 
52313     
52314   MATCH_label_c810: (void)0; /*placeholder for label*/ 
52315     { 
52316       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52317       nextPC = 4 + MATCH_p; 
52318       
52319 #line 1040 "frontend/machine/pentium/decoder.m"
52320       
52321 
52322             stmts = instantiate(pc,  "LTR", DIS_EADDR32);
52323 
52324       
52325 
52326       
52327       
52328       
52329     } 
52330     goto MATCH_finished_c; 
52331     
52332   MATCH_label_c811: (void)0; /*placeholder for label*/ 
52333     { 
52334       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52335       nextPC = 8 + MATCH_p; 
52336       
52337 #line 1040 "frontend/machine/pentium/decoder.m"
52338       
52339 
52340             stmts = instantiate(pc,  "LTR", DIS_EADDR32);
52341 
52342       
52343 
52344       
52345       
52346       
52347     } 
52348     goto MATCH_finished_c; 
52349     
52350   MATCH_label_c812: (void)0; /*placeholder for label*/ 
52351     { 
52352       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52353       nextPC = 7 + MATCH_p; 
52354       
52355 #line 1040 "frontend/machine/pentium/decoder.m"
52356       
52357 
52358             stmts = instantiate(pc,  "LTR", DIS_EADDR32);
52359 
52360       
52361 
52362       
52363       
52364       
52365     } 
52366     goto MATCH_finished_c; 
52367     
52368   MATCH_label_c813: (void)0; /*placeholder for label*/ 
52369     { 
52370       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52371       nextPC = 3 + MATCH_p; 
52372       
52373 #line 375 "frontend/machine/pentium/decoder.m"
52374       
52375 
52376             stmts = instantiate(pc,  "VERR", DIS_EADDR32);
52377 
52378       
52379 
52380       
52381       
52382       
52383     } 
52384     goto MATCH_finished_c; 
52385     
52386   MATCH_label_c814: (void)0; /*placeholder for label*/ 
52387     { 
52388       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52389       nextPC = 4 + MATCH_p; 
52390       
52391 #line 375 "frontend/machine/pentium/decoder.m"
52392       
52393 
52394             stmts = instantiate(pc,  "VERR", DIS_EADDR32);
52395 
52396       
52397 
52398       
52399       
52400       
52401     } 
52402     goto MATCH_finished_c; 
52403     
52404   MATCH_label_c815: (void)0; /*placeholder for label*/ 
52405     { 
52406       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52407       nextPC = 8 + MATCH_p; 
52408       
52409 #line 375 "frontend/machine/pentium/decoder.m"
52410       
52411 
52412             stmts = instantiate(pc,  "VERR", DIS_EADDR32);
52413 
52414       
52415 
52416       
52417       
52418       
52419     } 
52420     goto MATCH_finished_c; 
52421     
52422   MATCH_label_c816: (void)0; /*placeholder for label*/ 
52423     { 
52424       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52425       nextPC = 7 + MATCH_p; 
52426       
52427 #line 375 "frontend/machine/pentium/decoder.m"
52428       
52429 
52430             stmts = instantiate(pc,  "VERR", DIS_EADDR32);
52431 
52432       
52433 
52434       
52435       
52436       
52437     } 
52438     goto MATCH_finished_c; 
52439     
52440   MATCH_label_c817: (void)0; /*placeholder for label*/ 
52441     { 
52442       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52443       nextPC = 3 + MATCH_p; 
52444       
52445 #line 372 "frontend/machine/pentium/decoder.m"
52446       
52447 
52448             stmts = instantiate(pc,  "VERW", DIS_EADDR32);
52449 
52450       
52451 
52452       
52453       
52454       
52455     } 
52456     goto MATCH_finished_c; 
52457     
52458   MATCH_label_c818: (void)0; /*placeholder for label*/ 
52459     { 
52460       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52461       nextPC = 4 + MATCH_p; 
52462       
52463 #line 372 "frontend/machine/pentium/decoder.m"
52464       
52465 
52466             stmts = instantiate(pc,  "VERW", DIS_EADDR32);
52467 
52468       
52469 
52470       
52471       
52472       
52473     } 
52474     goto MATCH_finished_c; 
52475     
52476   MATCH_label_c819: (void)0; /*placeholder for label*/ 
52477     { 
52478       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52479       nextPC = 8 + MATCH_p; 
52480       
52481 #line 372 "frontend/machine/pentium/decoder.m"
52482       
52483 
52484             stmts = instantiate(pc,  "VERW", DIS_EADDR32);
52485 
52486       
52487 
52488       
52489       
52490       
52491     } 
52492     goto MATCH_finished_c; 
52493     
52494   MATCH_label_c820: (void)0; /*placeholder for label*/ 
52495     { 
52496       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52497       nextPC = 7 + MATCH_p; 
52498       
52499 #line 372 "frontend/machine/pentium/decoder.m"
52500       
52501 
52502             stmts = instantiate(pc,  "VERW", DIS_EADDR32);
52503 
52504       
52505 
52506       
52507       
52508       
52509     } 
52510     goto MATCH_finished_c; 
52511     
52512   MATCH_label_c821: (void)0; /*placeholder for label*/ 
52513     { 
52514       unsigned Mem = 2 + addressToPC(MATCH_p);
52515       nextPC = 4 + MATCH_p; 
52516       
52517 #line 459 "frontend/machine/pentium/decoder.m"
52518       
52519 
52520             stmts = instantiate(pc,  "SGDT", DIS_MEM);
52521 
52522       
52523 
52524         // Sets are now in the high level instructions
52525 
52526       
52527       
52528       
52529     } 
52530     goto MATCH_finished_c; 
52531     
52532   MATCH_label_c822: (void)0; /*placeholder for label*/ 
52533     { 
52534       unsigned Mem = 2 + addressToPC(MATCH_p);
52535       nextPC = 8 + MATCH_p; 
52536       
52537 #line 459 "frontend/machine/pentium/decoder.m"
52538       
52539 
52540             stmts = instantiate(pc,  "SGDT", DIS_MEM);
52541 
52542       
52543 
52544         // Sets are now in the high level instructions
52545 
52546       
52547       
52548       
52549     } 
52550     goto MATCH_finished_c; 
52551     
52552   MATCH_label_c823: (void)0; /*placeholder for label*/ 
52553     { 
52554       unsigned Mem = 2 + addressToPC(MATCH_p);
52555       nextPC = 7 + MATCH_p; 
52556       
52557 #line 459 "frontend/machine/pentium/decoder.m"
52558       
52559 
52560             stmts = instantiate(pc,  "SGDT", DIS_MEM);
52561 
52562       
52563 
52564         // Sets are now in the high level instructions
52565 
52566       
52567       
52568       
52569     } 
52570     goto MATCH_finished_c; 
52571     
52572   MATCH_label_c824: (void)0; /*placeholder for label*/ 
52573     { 
52574       unsigned Mem = 2 + addressToPC(MATCH_p);
52575       nextPC = 4 + MATCH_p; 
52576       
52577 #line 456 "frontend/machine/pentium/decoder.m"
52578       
52579 
52580             stmts = instantiate(pc,  "SIDT", DIS_MEM);
52581 
52582       
52583 
52584       
52585       
52586       
52587     } 
52588     goto MATCH_finished_c; 
52589     
52590   MATCH_label_c825: (void)0; /*placeholder for label*/ 
52591     { 
52592       unsigned Mem = 2 + addressToPC(MATCH_p);
52593       nextPC = 8 + MATCH_p; 
52594       
52595 #line 456 "frontend/machine/pentium/decoder.m"
52596       
52597 
52598             stmts = instantiate(pc,  "SIDT", DIS_MEM);
52599 
52600       
52601 
52602       
52603       
52604       
52605     } 
52606     goto MATCH_finished_c; 
52607     
52608   MATCH_label_c826: (void)0; /*placeholder for label*/ 
52609     { 
52610       unsigned Mem = 2 + addressToPC(MATCH_p);
52611       nextPC = 7 + MATCH_p; 
52612       
52613 #line 456 "frontend/machine/pentium/decoder.m"
52614       
52615 
52616             stmts = instantiate(pc,  "SIDT", DIS_MEM);
52617 
52618       
52619 
52620       
52621       
52622       
52623     } 
52624     goto MATCH_finished_c; 
52625     
52626   MATCH_label_c827: (void)0; /*placeholder for label*/ 
52627     { 
52628       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52629       nextPC = 3 + MATCH_p; 
52630       
52631 #line 426 "frontend/machine/pentium/decoder.m"
52632       
52633 
52634             stmts = instantiate(pc,  "SMSW", DIS_EADDR32);
52635 
52636       
52637 
52638       
52639       
52640       
52641     } 
52642     goto MATCH_finished_c; 
52643     
52644   MATCH_label_c828: (void)0; /*placeholder for label*/ 
52645     { 
52646       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52647       nextPC = 4 + MATCH_p; 
52648       
52649 #line 426 "frontend/machine/pentium/decoder.m"
52650       
52651 
52652             stmts = instantiate(pc,  "SMSW", DIS_EADDR32);
52653 
52654       
52655 
52656       
52657       
52658       
52659     } 
52660     goto MATCH_finished_c; 
52661     
52662   MATCH_label_c829: (void)0; /*placeholder for label*/ 
52663     { 
52664       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52665       nextPC = 8 + MATCH_p; 
52666       
52667 #line 426 "frontend/machine/pentium/decoder.m"
52668       
52669 
52670             stmts = instantiate(pc,  "SMSW", DIS_EADDR32);
52671 
52672       
52673 
52674       
52675       
52676       
52677     } 
52678     goto MATCH_finished_c; 
52679     
52680   MATCH_label_c830: (void)0; /*placeholder for label*/ 
52681     { 
52682       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52683       nextPC = 7 + MATCH_p; 
52684       
52685 #line 426 "frontend/machine/pentium/decoder.m"
52686       
52687 
52688             stmts = instantiate(pc,  "SMSW", DIS_EADDR32);
52689 
52690       
52691 
52692       
52693       
52694       
52695     } 
52696     goto MATCH_finished_c; 
52697     
52698   MATCH_label_c831: (void)0; /*placeholder for label*/ 
52699     { 
52700       unsigned Mem = 2 + addressToPC(MATCH_p);
52701       nextPC = 4 + MATCH_p; 
52702       
52703 #line 1095 "frontend/machine/pentium/decoder.m"
52704       
52705 
52706             stmts = instantiate(pc,  "INVLPG", DIS_MEM);
52707 
52708       
52709 
52710       
52711       
52712       
52713     } 
52714     goto MATCH_finished_c; 
52715     
52716   MATCH_label_c832: (void)0; /*placeholder for label*/ 
52717     { 
52718       unsigned Mem = 2 + addressToPC(MATCH_p);
52719       nextPC = 8 + MATCH_p; 
52720       
52721 #line 1095 "frontend/machine/pentium/decoder.m"
52722       
52723 
52724             stmts = instantiate(pc,  "INVLPG", DIS_MEM);
52725 
52726       
52727 
52728       
52729       
52730       
52731     } 
52732     goto MATCH_finished_c; 
52733     
52734   MATCH_label_c833: (void)0; /*placeholder for label*/ 
52735     { 
52736       unsigned Mem = 2 + addressToPC(MATCH_p);
52737       nextPC = 7 + MATCH_p; 
52738       
52739 #line 1095 "frontend/machine/pentium/decoder.m"
52740       
52741 
52742             stmts = instantiate(pc,  "INVLPG", DIS_MEM);
52743 
52744       
52745 
52746       
52747       
52748       
52749     } 
52750     goto MATCH_finished_c; 
52751     
52752   MATCH_label_c834: (void)0; /*placeholder for label*/ 
52753     { 
52754       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52755       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
52756       nextPC = 3 + MATCH_p; 
52757       
52758 #line 1082 "frontend/machine/pentium/decoder.m"
52759       
52760 
52761             stmts = instantiate(pc,  "LAR.od", DIS_REG32, DIS_EADDR32);
52762 
52763       
52764 
52765       
52766       
52767       
52768     } 
52769     goto MATCH_finished_c; 
52770     
52771   MATCH_label_c835: (void)0; /*placeholder for label*/ 
52772     { 
52773       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52774       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
52775       nextPC = 4 + MATCH_p; 
52776       
52777 #line 1082 "frontend/machine/pentium/decoder.m"
52778       
52779 
52780             stmts = instantiate(pc,  "LAR.od", DIS_REG32, DIS_EADDR32);
52781 
52782       
52783 
52784       
52785       
52786       
52787     } 
52788     goto MATCH_finished_c; 
52789     
52790   MATCH_label_c836: (void)0; /*placeholder for label*/ 
52791     { 
52792       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52793       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
52794       nextPC = 8 + MATCH_p; 
52795       
52796 #line 1082 "frontend/machine/pentium/decoder.m"
52797       
52798 
52799             stmts = instantiate(pc,  "LAR.od", DIS_REG32, DIS_EADDR32);
52800 
52801       
52802 
52803       
52804       
52805       
52806     } 
52807     goto MATCH_finished_c; 
52808     
52809   MATCH_label_c837: (void)0; /*placeholder for label*/ 
52810     { 
52811       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52812       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
52813       nextPC = 7 + MATCH_p; 
52814       
52815 #line 1082 "frontend/machine/pentium/decoder.m"
52816       
52817 
52818             stmts = instantiate(pc,  "LAR.od", DIS_REG32, DIS_EADDR32);
52819 
52820       
52821 
52822       
52823       
52824       
52825     } 
52826     goto MATCH_finished_c; 
52827     
52828   MATCH_label_c838: (void)0; /*placeholder for label*/ 
52829     { 
52830       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52831       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
52832       nextPC = 3 + MATCH_p; 
52833       
52834 #line 1046 "frontend/machine/pentium/decoder.m"
52835       
52836 
52837             stmts = instantiate(pc,  "LSLod", DIS_REG32, DIS_EADDR32);
52838 
52839       
52840 
52841       
52842       
52843       
52844     } 
52845     goto MATCH_finished_c; 
52846     
52847   MATCH_label_c839: (void)0; /*placeholder for label*/ 
52848     { 
52849       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52850       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
52851       nextPC = 4 + MATCH_p; 
52852       
52853 #line 1046 "frontend/machine/pentium/decoder.m"
52854       
52855 
52856             stmts = instantiate(pc,  "LSLod", DIS_REG32, DIS_EADDR32);
52857 
52858       
52859 
52860       
52861       
52862       
52863     } 
52864     goto MATCH_finished_c; 
52865     
52866   MATCH_label_c840: (void)0; /*placeholder for label*/ 
52867     { 
52868       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52869       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
52870       nextPC = 8 + MATCH_p; 
52871       
52872 #line 1046 "frontend/machine/pentium/decoder.m"
52873       
52874 
52875             stmts = instantiate(pc,  "LSLod", DIS_REG32, DIS_EADDR32);
52876 
52877       
52878 
52879       
52880       
52881       
52882     } 
52883     goto MATCH_finished_c; 
52884     
52885   MATCH_label_c841: (void)0; /*placeholder for label*/ 
52886     { 
52887       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52888       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
52889       nextPC = 7 + MATCH_p; 
52890       
52891 #line 1046 "frontend/machine/pentium/decoder.m"
52892       
52893 
52894             stmts = instantiate(pc,  "LSLod", DIS_REG32, DIS_EADDR32);
52895 
52896       
52897 
52898       
52899       
52900       
52901     } 
52902     goto MATCH_finished_c; 
52903     
52904   MATCH_label_c842: (void)0; /*placeholder for label*/ 
52905     { 
52906       char *name = MATCH_name;
52907       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52908       nextPC = 3 + MATCH_p; 
52909       
52910 #line 305 "frontend/machine/pentium/decoder.m"
52911       
52912 
52913             stmts = instantiate(pc, name, DIS_EADDR8);
52914 
52915             SETS(name, DIS_EADDR8, BRANCH_JUL)
52916 
52917         //| SETb.NO(Eaddr) [name] =>
52918 
52919         //  stmts = instantiate(pc, name, DIS_EADDR8);
52920 
52921         //  SETS(name, DIS_EADDR8, BRANCH_JSG)
52922 
52923         //| SETb.O(Eaddr) [name] =>
52924 
52925         //  stmts = instantiate(pc, name, DIS_EADDR8);
52926 
52927         //  SETS(name, DIS_EADDR8, BRANCH_JSG)
52928 
52929       
52930 
52931       
52932       
52933       
52934     } 
52935     goto MATCH_finished_c; 
52936     
52937   MATCH_label_c843: (void)0; /*placeholder for label*/ 
52938     { 
52939       char *name = MATCH_name;
52940       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52941       nextPC = 4 + MATCH_p; 
52942       
52943 #line 305 "frontend/machine/pentium/decoder.m"
52944       
52945 
52946             stmts = instantiate(pc, name, DIS_EADDR8);
52947 
52948             SETS(name, DIS_EADDR8, BRANCH_JUL)
52949 
52950         //| SETb.NO(Eaddr) [name] =>
52951 
52952         //  stmts = instantiate(pc, name, DIS_EADDR8);
52953 
52954         //  SETS(name, DIS_EADDR8, BRANCH_JSG)
52955 
52956         //| SETb.O(Eaddr) [name] =>
52957 
52958         //  stmts = instantiate(pc, name, DIS_EADDR8);
52959 
52960         //  SETS(name, DIS_EADDR8, BRANCH_JSG)
52961 
52962       
52963 
52964       
52965       
52966       
52967     } 
52968     goto MATCH_finished_c; 
52969     
52970   MATCH_label_c844: (void)0; /*placeholder for label*/ 
52971     { 
52972       char *name = MATCH_name;
52973       unsigned Eaddr = 2 + addressToPC(MATCH_p);
52974       nextPC = 8 + MATCH_p; 
52975       
52976 #line 305 "frontend/machine/pentium/decoder.m"
52977       
52978 
52979             stmts = instantiate(pc, name, DIS_EADDR8);
52980 
52981             SETS(name, DIS_EADDR8, BRANCH_JUL)
52982 
52983         //| SETb.NO(Eaddr) [name] =>
52984 
52985         //  stmts = instantiate(pc, name, DIS_EADDR8);
52986 
52987         //  SETS(name, DIS_EADDR8, BRANCH_JSG)
52988 
52989         //| SETb.O(Eaddr) [name] =>
52990 
52991         //  stmts = instantiate(pc, name, DIS_EADDR8);
52992 
52993         //  SETS(name, DIS_EADDR8, BRANCH_JSG)
52994 
52995       
52996 
52997       
52998       
52999       
53000     } 
53001     goto MATCH_finished_c; 
53002     
53003   MATCH_label_c845: (void)0; /*placeholder for label*/ 
53004     { 
53005       char *name = MATCH_name;
53006       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53007       nextPC = 7 + MATCH_p; 
53008       
53009 #line 305 "frontend/machine/pentium/decoder.m"
53010       
53011 
53012             stmts = instantiate(pc, name, DIS_EADDR8);
53013 
53014             SETS(name, DIS_EADDR8, BRANCH_JUL)
53015 
53016         //| SETb.NO(Eaddr) [name] =>
53017 
53018         //  stmts = instantiate(pc, name, DIS_EADDR8);
53019 
53020         //  SETS(name, DIS_EADDR8, BRANCH_JSG)
53021 
53022         //| SETb.O(Eaddr) [name] =>
53023 
53024         //  stmts = instantiate(pc, name, DIS_EADDR8);
53025 
53026         //  SETS(name, DIS_EADDR8, BRANCH_JSG)
53027 
53028       
53029 
53030       
53031       
53032       
53033     } 
53034     goto MATCH_finished_c; 
53035     
53036   MATCH_label_c846: (void)0; /*placeholder for label*/ 
53037     { 
53038       char *name = MATCH_name;
53039       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53040       nextPC = 3 + MATCH_p; 
53041       
53042 #line 302 "frontend/machine/pentium/decoder.m"
53043       
53044 
53045             stmts = instantiate(pc, name, DIS_EADDR8);
53046 
53047             SETS(name, DIS_EADDR8, BRANCH_JUGE)
53048 
53049       
53050       
53051       
53052     } 
53053     goto MATCH_finished_c; 
53054     
53055   MATCH_label_c847: (void)0; /*placeholder for label*/ 
53056     { 
53057       char *name = MATCH_name;
53058       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53059       nextPC = 4 + MATCH_p; 
53060       
53061 #line 302 "frontend/machine/pentium/decoder.m"
53062       
53063 
53064             stmts = instantiate(pc, name, DIS_EADDR8);
53065 
53066             SETS(name, DIS_EADDR8, BRANCH_JUGE)
53067 
53068       
53069       
53070       
53071     } 
53072     goto MATCH_finished_c; 
53073     
53074   MATCH_label_c848: (void)0; /*placeholder for label*/ 
53075     { 
53076       char *name = MATCH_name;
53077       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53078       nextPC = 8 + MATCH_p; 
53079       
53080 #line 302 "frontend/machine/pentium/decoder.m"
53081       
53082 
53083             stmts = instantiate(pc, name, DIS_EADDR8);
53084 
53085             SETS(name, DIS_EADDR8, BRANCH_JUGE)
53086 
53087       
53088       
53089       
53090     } 
53091     goto MATCH_finished_c; 
53092     
53093   MATCH_label_c849: (void)0; /*placeholder for label*/ 
53094     { 
53095       char *name = MATCH_name;
53096       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53097       nextPC = 7 + MATCH_p; 
53098       
53099 #line 302 "frontend/machine/pentium/decoder.m"
53100       
53101 
53102             stmts = instantiate(pc, name, DIS_EADDR8);
53103 
53104             SETS(name, DIS_EADDR8, BRANCH_JUGE)
53105 
53106       
53107       
53108       
53109     } 
53110     goto MATCH_finished_c; 
53111     
53112   MATCH_label_c850: (void)0; /*placeholder for label*/ 
53113     { 
53114       char *name = MATCH_name;
53115       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53116       nextPC = 3 + MATCH_p; 
53117       
53118 #line 299 "frontend/machine/pentium/decoder.m"
53119       
53120 
53121             stmts = instantiate(pc, name, DIS_EADDR8);
53122 
53123             SETS(name, DIS_EADDR8, BRANCH_JE)
53124 
53125       
53126       
53127       
53128     } 
53129     goto MATCH_finished_c; 
53130     
53131   MATCH_label_c851: (void)0; /*placeholder for label*/ 
53132     { 
53133       char *name = MATCH_name;
53134       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53135       nextPC = 4 + MATCH_p; 
53136       
53137 #line 299 "frontend/machine/pentium/decoder.m"
53138       
53139 
53140             stmts = instantiate(pc, name, DIS_EADDR8);
53141 
53142             SETS(name, DIS_EADDR8, BRANCH_JE)
53143 
53144       
53145       
53146       
53147     } 
53148     goto MATCH_finished_c; 
53149     
53150   MATCH_label_c852: (void)0; /*placeholder for label*/ 
53151     { 
53152       char *name = MATCH_name;
53153       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53154       nextPC = 8 + MATCH_p; 
53155       
53156 #line 299 "frontend/machine/pentium/decoder.m"
53157       
53158 
53159             stmts = instantiate(pc, name, DIS_EADDR8);
53160 
53161             SETS(name, DIS_EADDR8, BRANCH_JE)
53162 
53163       
53164       
53165       
53166     } 
53167     goto MATCH_finished_c; 
53168     
53169   MATCH_label_c853: (void)0; /*placeholder for label*/ 
53170     { 
53171       char *name = MATCH_name;
53172       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53173       nextPC = 7 + MATCH_p; 
53174       
53175 #line 299 "frontend/machine/pentium/decoder.m"
53176       
53177 
53178             stmts = instantiate(pc, name, DIS_EADDR8);
53179 
53180             SETS(name, DIS_EADDR8, BRANCH_JE)
53181 
53182       
53183       
53184       
53185     } 
53186     goto MATCH_finished_c; 
53187     
53188   MATCH_label_c854: (void)0; /*placeholder for label*/ 
53189     { 
53190       char *name = MATCH_name;
53191       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53192       nextPC = 3 + MATCH_p; 
53193       
53194 #line 296 "frontend/machine/pentium/decoder.m"
53195       
53196 
53197             stmts = instantiate(pc, name, DIS_EADDR8);
53198 
53199             SETS(name, DIS_EADDR8, BRANCH_JNE)
53200 
53201       
53202       
53203       
53204     } 
53205     goto MATCH_finished_c; 
53206     
53207   MATCH_label_c855: (void)0; /*placeholder for label*/ 
53208     { 
53209       char *name = MATCH_name;
53210       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53211       nextPC = 4 + MATCH_p; 
53212       
53213 #line 296 "frontend/machine/pentium/decoder.m"
53214       
53215 
53216             stmts = instantiate(pc, name, DIS_EADDR8);
53217 
53218             SETS(name, DIS_EADDR8, BRANCH_JNE)
53219 
53220       
53221       
53222       
53223     } 
53224     goto MATCH_finished_c; 
53225     
53226   MATCH_label_c856: (void)0; /*placeholder for label*/ 
53227     { 
53228       char *name = MATCH_name;
53229       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53230       nextPC = 8 + MATCH_p; 
53231       
53232 #line 296 "frontend/machine/pentium/decoder.m"
53233       
53234 
53235             stmts = instantiate(pc, name, DIS_EADDR8);
53236 
53237             SETS(name, DIS_EADDR8, BRANCH_JNE)
53238 
53239       
53240       
53241       
53242     } 
53243     goto MATCH_finished_c; 
53244     
53245   MATCH_label_c857: (void)0; /*placeholder for label*/ 
53246     { 
53247       char *name = MATCH_name;
53248       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53249       nextPC = 7 + MATCH_p; 
53250       
53251 #line 296 "frontend/machine/pentium/decoder.m"
53252       
53253 
53254             stmts = instantiate(pc, name, DIS_EADDR8);
53255 
53256             SETS(name, DIS_EADDR8, BRANCH_JNE)
53257 
53258       
53259       
53260       
53261     } 
53262     goto MATCH_finished_c; 
53263     
53264   MATCH_label_c858: (void)0; /*placeholder for label*/ 
53265     { 
53266       char *name = MATCH_name;
53267       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53268       nextPC = 3 + MATCH_p; 
53269       
53270 #line 293 "frontend/machine/pentium/decoder.m"
53271       
53272 
53273             stmts = instantiate(pc, name, DIS_EADDR8);
53274 
53275             SETS(name, DIS_EADDR8, BRANCH_JULE)
53276 
53277       
53278       
53279       
53280     } 
53281     goto MATCH_finished_c; 
53282     
53283   MATCH_label_c859: (void)0; /*placeholder for label*/ 
53284     { 
53285       char *name = MATCH_name;
53286       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53287       nextPC = 4 + MATCH_p; 
53288       
53289 #line 293 "frontend/machine/pentium/decoder.m"
53290       
53291 
53292             stmts = instantiate(pc, name, DIS_EADDR8);
53293 
53294             SETS(name, DIS_EADDR8, BRANCH_JULE)
53295 
53296       
53297       
53298       
53299     } 
53300     goto MATCH_finished_c; 
53301     
53302   MATCH_label_c860: (void)0; /*placeholder for label*/ 
53303     { 
53304       char *name = MATCH_name;
53305       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53306       nextPC = 8 + MATCH_p; 
53307       
53308 #line 293 "frontend/machine/pentium/decoder.m"
53309       
53310 
53311             stmts = instantiate(pc, name, DIS_EADDR8);
53312 
53313             SETS(name, DIS_EADDR8, BRANCH_JULE)
53314 
53315       
53316       
53317       
53318     } 
53319     goto MATCH_finished_c; 
53320     
53321   MATCH_label_c861: (void)0; /*placeholder for label*/ 
53322     { 
53323       char *name = MATCH_name;
53324       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53325       nextPC = 7 + MATCH_p; 
53326       
53327 #line 293 "frontend/machine/pentium/decoder.m"
53328       
53329 
53330             stmts = instantiate(pc, name, DIS_EADDR8);
53331 
53332             SETS(name, DIS_EADDR8, BRANCH_JULE)
53333 
53334       
53335       
53336       
53337     } 
53338     goto MATCH_finished_c; 
53339     
53340   MATCH_label_c862: (void)0; /*placeholder for label*/ 
53341     { 
53342       char *name = MATCH_name;
53343       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53344       nextPC = 3 + MATCH_p; 
53345       
53346 #line 290 "frontend/machine/pentium/decoder.m"
53347       
53348 
53349             stmts = instantiate(pc, name, DIS_EADDR8);
53350 
53351             SETS(name, DIS_EADDR8, BRANCH_JUG)
53352 
53353       
53354       
53355       
53356     } 
53357     goto MATCH_finished_c; 
53358     
53359   MATCH_label_c863: (void)0; /*placeholder for label*/ 
53360     { 
53361       char *name = MATCH_name;
53362       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53363       nextPC = 4 + MATCH_p; 
53364       
53365 #line 290 "frontend/machine/pentium/decoder.m"
53366       
53367 
53368             stmts = instantiate(pc, name, DIS_EADDR8);
53369 
53370             SETS(name, DIS_EADDR8, BRANCH_JUG)
53371 
53372       
53373       
53374       
53375     } 
53376     goto MATCH_finished_c; 
53377     
53378   MATCH_label_c864: (void)0; /*placeholder for label*/ 
53379     { 
53380       char *name = MATCH_name;
53381       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53382       nextPC = 8 + MATCH_p; 
53383       
53384 #line 290 "frontend/machine/pentium/decoder.m"
53385       
53386 
53387             stmts = instantiate(pc, name, DIS_EADDR8);
53388 
53389             SETS(name, DIS_EADDR8, BRANCH_JUG)
53390 
53391       
53392       
53393       
53394     } 
53395     goto MATCH_finished_c; 
53396     
53397   MATCH_label_c865: (void)0; /*placeholder for label*/ 
53398     { 
53399       char *name = MATCH_name;
53400       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53401       nextPC = 7 + MATCH_p; 
53402       
53403 #line 290 "frontend/machine/pentium/decoder.m"
53404       
53405 
53406             stmts = instantiate(pc, name, DIS_EADDR8);
53407 
53408             SETS(name, DIS_EADDR8, BRANCH_JUG)
53409 
53410       
53411       
53412       
53413     } 
53414     goto MATCH_finished_c; 
53415     
53416   MATCH_label_c866: (void)0; /*placeholder for label*/ 
53417     { 
53418       char *name = MATCH_name;
53419       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53420       nextPC = 3 + MATCH_p; 
53421       
53422 #line 287 "frontend/machine/pentium/decoder.m"
53423       
53424 
53425             stmts = instantiate(pc, name, DIS_EADDR8);
53426 
53427             SETS(name, DIS_EADDR8, BRANCH_JMI)
53428 
53429       
53430       
53431       
53432     } 
53433     goto MATCH_finished_c; 
53434     
53435   MATCH_label_c867: (void)0; /*placeholder for label*/ 
53436     { 
53437       char *name = MATCH_name;
53438       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53439       nextPC = 4 + MATCH_p; 
53440       
53441 #line 287 "frontend/machine/pentium/decoder.m"
53442       
53443 
53444             stmts = instantiate(pc, name, DIS_EADDR8);
53445 
53446             SETS(name, DIS_EADDR8, BRANCH_JMI)
53447 
53448       
53449       
53450       
53451     } 
53452     goto MATCH_finished_c; 
53453     
53454   MATCH_label_c868: (void)0; /*placeholder for label*/ 
53455     { 
53456       char *name = MATCH_name;
53457       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53458       nextPC = 8 + MATCH_p; 
53459       
53460 #line 287 "frontend/machine/pentium/decoder.m"
53461       
53462 
53463             stmts = instantiate(pc, name, DIS_EADDR8);
53464 
53465             SETS(name, DIS_EADDR8, BRANCH_JMI)
53466 
53467       
53468       
53469       
53470     } 
53471     goto MATCH_finished_c; 
53472     
53473   MATCH_label_c869: (void)0; /*placeholder for label*/ 
53474     { 
53475       char *name = MATCH_name;
53476       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53477       nextPC = 7 + MATCH_p; 
53478       
53479 #line 287 "frontend/machine/pentium/decoder.m"
53480       
53481 
53482             stmts = instantiate(pc, name, DIS_EADDR8);
53483 
53484             SETS(name, DIS_EADDR8, BRANCH_JMI)
53485 
53486       
53487       
53488       
53489     } 
53490     goto MATCH_finished_c; 
53491     
53492   MATCH_label_c870: (void)0; /*placeholder for label*/ 
53493     { 
53494       char *name = MATCH_name;
53495       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53496       nextPC = 3 + MATCH_p; 
53497       
53498 #line 284 "frontend/machine/pentium/decoder.m"
53499       
53500 
53501             stmts = instantiate(pc, name, DIS_EADDR8);
53502 
53503             SETS(name, DIS_EADDR8, BRANCH_JPOS)
53504 
53505       
53506       
53507       
53508     } 
53509     goto MATCH_finished_c; 
53510     
53511   MATCH_label_c871: (void)0; /*placeholder for label*/ 
53512     { 
53513       char *name = MATCH_name;
53514       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53515       nextPC = 4 + MATCH_p; 
53516       
53517 #line 284 "frontend/machine/pentium/decoder.m"
53518       
53519 
53520             stmts = instantiate(pc, name, DIS_EADDR8);
53521 
53522             SETS(name, DIS_EADDR8, BRANCH_JPOS)
53523 
53524       
53525       
53526       
53527     } 
53528     goto MATCH_finished_c; 
53529     
53530   MATCH_label_c872: (void)0; /*placeholder for label*/ 
53531     { 
53532       char *name = MATCH_name;
53533       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53534       nextPC = 8 + MATCH_p; 
53535       
53536 #line 284 "frontend/machine/pentium/decoder.m"
53537       
53538 
53539             stmts = instantiate(pc, name, DIS_EADDR8);
53540 
53541             SETS(name, DIS_EADDR8, BRANCH_JPOS)
53542 
53543       
53544       
53545       
53546     } 
53547     goto MATCH_finished_c; 
53548     
53549   MATCH_label_c873: (void)0; /*placeholder for label*/ 
53550     { 
53551       char *name = MATCH_name;
53552       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53553       nextPC = 7 + MATCH_p; 
53554       
53555 #line 284 "frontend/machine/pentium/decoder.m"
53556       
53557 
53558             stmts = instantiate(pc, name, DIS_EADDR8);
53559 
53560             SETS(name, DIS_EADDR8, BRANCH_JPOS)
53561 
53562       
53563       
53564       
53565     } 
53566     goto MATCH_finished_c; 
53567     
53568   MATCH_label_c874: (void)0; /*placeholder for label*/ 
53569     { 
53570       char *name = MATCH_name;
53571       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53572       nextPC = 3 + MATCH_p; 
53573       
53574 #line 275 "frontend/machine/pentium/decoder.m"
53575       
53576 
53577             stmts = instantiate(pc, name, DIS_EADDR8);
53578 
53579             SETS(name, DIS_EADDR8, BRANCH_JSL)
53580 
53581         //| SETb.NP(Eaddr) [name] =>
53582 
53583         //  stmts = instantiate(pc, name, DIS_EADDR8);
53584 
53585         //  SETS(name, DIS_EADDR8, BRANCH_JSG)
53586 
53587         //| SETb.P(Eaddr) [name] =>
53588 
53589         //  stmts = instantiate(pc, name, DIS_EADDR8);
53590 
53591         //  SETS(name, DIS_EADDR8, BRANCH_JSG)
53592 
53593       
53594       
53595       
53596     } 
53597     goto MATCH_finished_c; 
53598     
53599   MATCH_label_c875: (void)0; /*placeholder for label*/ 
53600     { 
53601       char *name = MATCH_name;
53602       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53603       nextPC = 4 + MATCH_p; 
53604       
53605 #line 275 "frontend/machine/pentium/decoder.m"
53606       
53607 
53608             stmts = instantiate(pc, name, DIS_EADDR8);
53609 
53610             SETS(name, DIS_EADDR8, BRANCH_JSL)
53611 
53612         //| SETb.NP(Eaddr) [name] =>
53613 
53614         //  stmts = instantiate(pc, name, DIS_EADDR8);
53615 
53616         //  SETS(name, DIS_EADDR8, BRANCH_JSG)
53617 
53618         //| SETb.P(Eaddr) [name] =>
53619 
53620         //  stmts = instantiate(pc, name, DIS_EADDR8);
53621 
53622         //  SETS(name, DIS_EADDR8, BRANCH_JSG)
53623 
53624       
53625       
53626       
53627     } 
53628     goto MATCH_finished_c; 
53629     
53630   MATCH_label_c876: (void)0; /*placeholder for label*/ 
53631     { 
53632       char *name = MATCH_name;
53633       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53634       nextPC = 8 + MATCH_p; 
53635       
53636 #line 275 "frontend/machine/pentium/decoder.m"
53637       
53638 
53639             stmts = instantiate(pc, name, DIS_EADDR8);
53640 
53641             SETS(name, DIS_EADDR8, BRANCH_JSL)
53642 
53643         //| SETb.NP(Eaddr) [name] =>
53644 
53645         //  stmts = instantiate(pc, name, DIS_EADDR8);
53646 
53647         //  SETS(name, DIS_EADDR8, BRANCH_JSG)
53648 
53649         //| SETb.P(Eaddr) [name] =>
53650 
53651         //  stmts = instantiate(pc, name, DIS_EADDR8);
53652 
53653         //  SETS(name, DIS_EADDR8, BRANCH_JSG)
53654 
53655       
53656       
53657       
53658     } 
53659     goto MATCH_finished_c; 
53660     
53661   MATCH_label_c877: (void)0; /*placeholder for label*/ 
53662     { 
53663       char *name = MATCH_name;
53664       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53665       nextPC = 7 + MATCH_p; 
53666       
53667 #line 275 "frontend/machine/pentium/decoder.m"
53668       
53669 
53670             stmts = instantiate(pc, name, DIS_EADDR8);
53671 
53672             SETS(name, DIS_EADDR8, BRANCH_JSL)
53673 
53674         //| SETb.NP(Eaddr) [name] =>
53675 
53676         //  stmts = instantiate(pc, name, DIS_EADDR8);
53677 
53678         //  SETS(name, DIS_EADDR8, BRANCH_JSG)
53679 
53680         //| SETb.P(Eaddr) [name] =>
53681 
53682         //  stmts = instantiate(pc, name, DIS_EADDR8);
53683 
53684         //  SETS(name, DIS_EADDR8, BRANCH_JSG)
53685 
53686       
53687       
53688       
53689     } 
53690     goto MATCH_finished_c; 
53691     
53692   MATCH_label_c878: (void)0; /*placeholder for label*/ 
53693     { 
53694       char *name = MATCH_name;
53695       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53696       nextPC = 3 + MATCH_p; 
53697       
53698 #line 272 "frontend/machine/pentium/decoder.m"
53699       
53700 
53701             stmts = instantiate(pc, name, DIS_EADDR8);
53702 
53703             SETS(name, DIS_EADDR8, BRANCH_JSGE)
53704 
53705       
53706       
53707       
53708     } 
53709     goto MATCH_finished_c; 
53710     
53711   MATCH_label_c879: (void)0; /*placeholder for label*/ 
53712     { 
53713       char *name = MATCH_name;
53714       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53715       nextPC = 4 + MATCH_p; 
53716       
53717 #line 272 "frontend/machine/pentium/decoder.m"
53718       
53719 
53720             stmts = instantiate(pc, name, DIS_EADDR8);
53721 
53722             SETS(name, DIS_EADDR8, BRANCH_JSGE)
53723 
53724       
53725       
53726       
53727     } 
53728     goto MATCH_finished_c; 
53729     
53730   MATCH_label_c880: (void)0; /*placeholder for label*/ 
53731     { 
53732       char *name = MATCH_name;
53733       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53734       nextPC = 8 + MATCH_p; 
53735       
53736 #line 272 "frontend/machine/pentium/decoder.m"
53737       
53738 
53739             stmts = instantiate(pc, name, DIS_EADDR8);
53740 
53741             SETS(name, DIS_EADDR8, BRANCH_JSGE)
53742 
53743       
53744       
53745       
53746     } 
53747     goto MATCH_finished_c; 
53748     
53749   MATCH_label_c881: (void)0; /*placeholder for label*/ 
53750     { 
53751       char *name = MATCH_name;
53752       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53753       nextPC = 7 + MATCH_p; 
53754       
53755 #line 272 "frontend/machine/pentium/decoder.m"
53756       
53757 
53758             stmts = instantiate(pc, name, DIS_EADDR8);
53759 
53760             SETS(name, DIS_EADDR8, BRANCH_JSGE)
53761 
53762       
53763       
53764       
53765     } 
53766     goto MATCH_finished_c; 
53767     
53768   MATCH_label_c882: (void)0; /*placeholder for label*/ 
53769     { 
53770       char *name = MATCH_name;
53771       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53772       nextPC = 3 + MATCH_p; 
53773       
53774 #line 269 "frontend/machine/pentium/decoder.m"
53775       
53776 
53777             stmts = instantiate(pc, name, DIS_EADDR8);
53778 
53779             SETS(name, DIS_EADDR8, BRANCH_JSLE)
53780 
53781       
53782       
53783       
53784     } 
53785     goto MATCH_finished_c; 
53786     
53787   MATCH_label_c883: (void)0; /*placeholder for label*/ 
53788     { 
53789       char *name = MATCH_name;
53790       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53791       nextPC = 4 + MATCH_p; 
53792       
53793 #line 269 "frontend/machine/pentium/decoder.m"
53794       
53795 
53796             stmts = instantiate(pc, name, DIS_EADDR8);
53797 
53798             SETS(name, DIS_EADDR8, BRANCH_JSLE)
53799 
53800       
53801       
53802       
53803     } 
53804     goto MATCH_finished_c; 
53805     
53806   MATCH_label_c884: (void)0; /*placeholder for label*/ 
53807     { 
53808       char *name = MATCH_name;
53809       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53810       nextPC = 8 + MATCH_p; 
53811       
53812 #line 269 "frontend/machine/pentium/decoder.m"
53813       
53814 
53815             stmts = instantiate(pc, name, DIS_EADDR8);
53816 
53817             SETS(name, DIS_EADDR8, BRANCH_JSLE)
53818 
53819       
53820       
53821       
53822     } 
53823     goto MATCH_finished_c; 
53824     
53825   MATCH_label_c885: (void)0; /*placeholder for label*/ 
53826     { 
53827       char *name = MATCH_name;
53828       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53829       nextPC = 7 + MATCH_p; 
53830       
53831 #line 269 "frontend/machine/pentium/decoder.m"
53832       
53833 
53834             stmts = instantiate(pc, name, DIS_EADDR8);
53835 
53836             SETS(name, DIS_EADDR8, BRANCH_JSLE)
53837 
53838       
53839       
53840       
53841     } 
53842     goto MATCH_finished_c; 
53843     
53844   MATCH_label_c886: (void)0; /*placeholder for label*/ 
53845     { 
53846       char *name = MATCH_name;
53847       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53848       nextPC = 3 + MATCH_p; 
53849       
53850 #line 266 "frontend/machine/pentium/decoder.m"
53851       
53852 
53853             stmts = instantiate(pc, name, DIS_EADDR8);
53854 
53855             SETS(name, DIS_EADDR8, BRANCH_JSG)
53856 
53857       
53858       
53859       
53860     } 
53861     goto MATCH_finished_c; 
53862     
53863   MATCH_label_c887: (void)0; /*placeholder for label*/ 
53864     { 
53865       char *name = MATCH_name;
53866       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53867       nextPC = 4 + MATCH_p; 
53868       
53869 #line 266 "frontend/machine/pentium/decoder.m"
53870       
53871 
53872             stmts = instantiate(pc, name, DIS_EADDR8);
53873 
53874             SETS(name, DIS_EADDR8, BRANCH_JSG)
53875 
53876       
53877       
53878       
53879     } 
53880     goto MATCH_finished_c; 
53881     
53882   MATCH_label_c888: (void)0; /*placeholder for label*/ 
53883     { 
53884       char *name = MATCH_name;
53885       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53886       nextPC = 8 + MATCH_p; 
53887       
53888 #line 266 "frontend/machine/pentium/decoder.m"
53889       
53890 
53891             stmts = instantiate(pc, name, DIS_EADDR8);
53892 
53893             SETS(name, DIS_EADDR8, BRANCH_JSG)
53894 
53895       
53896       
53897       
53898     } 
53899     goto MATCH_finished_c; 
53900     
53901   MATCH_label_c889: (void)0; /*placeholder for label*/ 
53902     { 
53903       char *name = MATCH_name;
53904       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53905       nextPC = 7 + MATCH_p; 
53906       
53907 #line 266 "frontend/machine/pentium/decoder.m"
53908       
53909 
53910             stmts = instantiate(pc, name, DIS_EADDR8);
53911 
53912             SETS(name, DIS_EADDR8, BRANCH_JSG)
53913 
53914       
53915       
53916       
53917     } 
53918     goto MATCH_finished_c; 
53919     
53920   MATCH_label_c890: (void)0; /*placeholder for label*/ 
53921     { 
53922       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53923       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
53924       nextPC = 3 + MATCH_p; 
53925       
53926 #line 1352 "frontend/machine/pentium/decoder.m"
53927       
53928 
53929             stmts = instantiate(pc,  "BTod", DIS_EADDR32, DIS_REG32);
53930 
53931       
53932 
53933       
53934       
53935       
53936     } 
53937     goto MATCH_finished_c; 
53938     
53939   MATCH_label_c891: (void)0; /*placeholder for label*/ 
53940     { 
53941       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53942       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
53943       nextPC = 4 + MATCH_p; 
53944       
53945 #line 1352 "frontend/machine/pentium/decoder.m"
53946       
53947 
53948             stmts = instantiate(pc,  "BTod", DIS_EADDR32, DIS_REG32);
53949 
53950       
53951 
53952       
53953       
53954       
53955     } 
53956     goto MATCH_finished_c; 
53957     
53958   MATCH_label_c892: (void)0; /*placeholder for label*/ 
53959     { 
53960       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53961       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
53962       nextPC = 8 + MATCH_p; 
53963       
53964 #line 1352 "frontend/machine/pentium/decoder.m"
53965       
53966 
53967             stmts = instantiate(pc,  "BTod", DIS_EADDR32, DIS_REG32);
53968 
53969       
53970 
53971       
53972       
53973       
53974     } 
53975     goto MATCH_finished_c; 
53976     
53977   MATCH_label_c893: (void)0; /*placeholder for label*/ 
53978     { 
53979       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53980       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
53981       nextPC = 7 + MATCH_p; 
53982       
53983 #line 1352 "frontend/machine/pentium/decoder.m"
53984       
53985 
53986             stmts = instantiate(pc,  "BTod", DIS_EADDR32, DIS_REG32);
53987 
53988       
53989 
53990       
53991       
53992       
53993     } 
53994     goto MATCH_finished_c; 
53995     
53996   MATCH_label_c894: (void)0; /*placeholder for label*/ 
53997     { 
53998       unsigned Eaddr = 2 + addressToPC(MATCH_p);
53999       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54000       nextPC = 3 + MATCH_p; 
54001       
54002 #line 1316 "frontend/machine/pentium/decoder.m"
54003       
54004 
54005             stmts = instantiate(pc,  "BTSod", DIS_EADDR32, DIS_REG32);
54006 
54007       
54008 
54009       
54010       
54011       
54012     } 
54013     goto MATCH_finished_c; 
54014     
54015   MATCH_label_c895: (void)0; /*placeholder for label*/ 
54016     { 
54017       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54018       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54019       nextPC = 4 + MATCH_p; 
54020       
54021 #line 1316 "frontend/machine/pentium/decoder.m"
54022       
54023 
54024             stmts = instantiate(pc,  "BTSod", DIS_EADDR32, DIS_REG32);
54025 
54026       
54027 
54028       
54029       
54030       
54031     } 
54032     goto MATCH_finished_c; 
54033     
54034   MATCH_label_c896: (void)0; /*placeholder for label*/ 
54035     { 
54036       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54037       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54038       nextPC = 8 + MATCH_p; 
54039       
54040 #line 1316 "frontend/machine/pentium/decoder.m"
54041       
54042 
54043             stmts = instantiate(pc,  "BTSod", DIS_EADDR32, DIS_REG32);
54044 
54045       
54046 
54047       
54048       
54049       
54050     } 
54051     goto MATCH_finished_c; 
54052     
54053   MATCH_label_c897: (void)0; /*placeholder for label*/ 
54054     { 
54055       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54056       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54057       nextPC = 7 + MATCH_p; 
54058       
54059 #line 1316 "frontend/machine/pentium/decoder.m"
54060       
54061 
54062             stmts = instantiate(pc,  "BTSod", DIS_EADDR32, DIS_REG32);
54063 
54064       
54065 
54066       
54067       
54068       
54069     } 
54070     goto MATCH_finished_c; 
54071     
54072   MATCH_label_c898: (void)0; /*placeholder for label*/ 
54073     { 
54074       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54075       unsigned count = (MATCH_w_8_24 & 0xff) /* i8 at 24 */;
54076       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54077       nextPC = 4 + MATCH_p; 
54078       
54079 #line 444 "frontend/machine/pentium/decoder.m"
54080       
54081 
54082             stmts = instantiate(pc,  "SHLD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
54083 
54084       
54085 
54086       
54087       
54088       
54089     } 
54090     goto MATCH_finished_c; 
54091     
54092   MATCH_label_c899: (void)0; /*placeholder for label*/ 
54093     { 
54094       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54095       unsigned count = (MATCH_w_8_32 & 0xff) /* i8 at 32 */;
54096       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54097       nextPC = 5 + MATCH_p; 
54098       
54099 #line 444 "frontend/machine/pentium/decoder.m"
54100       
54101 
54102             stmts = instantiate(pc,  "SHLD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
54103 
54104       
54105 
54106       
54107       
54108       
54109     } 
54110     goto MATCH_finished_c; 
54111     
54112   MATCH_label_c900: (void)0; /*placeholder for label*/ 
54113     { 
54114       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54115       unsigned count = (MATCH_w_8_64 & 0xff) /* i8 at 64 */;
54116       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54117       nextPC = 9 + MATCH_p; 
54118       
54119 #line 444 "frontend/machine/pentium/decoder.m"
54120       
54121 
54122             stmts = instantiate(pc,  "SHLD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
54123 
54124       
54125 
54126       
54127       
54128       
54129     } 
54130     goto MATCH_finished_c; 
54131     
54132   MATCH_label_c901: (void)0; /*placeholder for label*/ 
54133     { 
54134       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54135       unsigned count = (MATCH_w_8_56 & 0xff) /* i8 at 56 */;
54136       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54137       nextPC = 8 + MATCH_p; 
54138       
54139 #line 444 "frontend/machine/pentium/decoder.m"
54140       
54141 
54142             stmts = instantiate(pc,  "SHLD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
54143 
54144       
54145 
54146       
54147       
54148       
54149     } 
54150     goto MATCH_finished_c; 
54151     
54152   MATCH_label_c902: (void)0; /*placeholder for label*/ 
54153     { 
54154       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54155       unsigned count = (MATCH_w_8_24 & 0xff) /* i8 at 24 */;
54156       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54157       nextPC = 4 + MATCH_p; 
54158       
54159 #line 450 "frontend/machine/pentium/decoder.m"
54160       
54161 
54162             stmts = instantiate(pc,  "SHRD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
54163 
54164       
54165 
54166       
54167       
54168       
54169     } 
54170     goto MATCH_finished_c; 
54171     
54172   MATCH_label_c903: (void)0; /*placeholder for label*/ 
54173     { 
54174       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54175       unsigned count = (MATCH_w_8_32 & 0xff) /* i8 at 32 */;
54176       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54177       nextPC = 5 + MATCH_p; 
54178       
54179 #line 450 "frontend/machine/pentium/decoder.m"
54180       
54181 
54182             stmts = instantiate(pc,  "SHRD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
54183 
54184       
54185 
54186       
54187       
54188       
54189     } 
54190     goto MATCH_finished_c; 
54191     
54192   MATCH_label_c904: (void)0; /*placeholder for label*/ 
54193     { 
54194       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54195       unsigned count = (MATCH_w_8_64 & 0xff) /* i8 at 64 */;
54196       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54197       nextPC = 9 + MATCH_p; 
54198       
54199 #line 450 "frontend/machine/pentium/decoder.m"
54200       
54201 
54202             stmts = instantiate(pc,  "SHRD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
54203 
54204       
54205 
54206       
54207       
54208       
54209     } 
54210     goto MATCH_finished_c; 
54211     
54212   MATCH_label_c905: (void)0; /*placeholder for label*/ 
54213     { 
54214       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54215       unsigned count = (MATCH_w_8_56 & 0xff) /* i8 at 56 */;
54216       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54217       nextPC = 8 + MATCH_p; 
54218       
54219 #line 450 "frontend/machine/pentium/decoder.m"
54220       
54221 
54222             stmts = instantiate(pc,  "SHRD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
54223 
54224       
54225 
54226       
54227       
54228       
54229     } 
54230     goto MATCH_finished_c; 
54231     
54232   MATCH_label_c906: (void)0; /*placeholder for label*/ 
54233     { 
54234       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54235       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54236       nextPC = 3 + MATCH_p; 
54237       
54238 #line 432 "frontend/machine/pentium/decoder.m"
54239       
54240 
54241             stmts = instantiate(pc,  "SHLD.CLod", DIS_EADDR32, DIS_REG32);
54242 
54243       
54244 
54245       
54246       
54247       
54248     } 
54249     goto MATCH_finished_c; 
54250     
54251   MATCH_label_c907: (void)0; /*placeholder for label*/ 
54252     { 
54253       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54254       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54255       nextPC = 4 + MATCH_p; 
54256       
54257 #line 432 "frontend/machine/pentium/decoder.m"
54258       
54259 
54260             stmts = instantiate(pc,  "SHLD.CLod", DIS_EADDR32, DIS_REG32);
54261 
54262       
54263 
54264       
54265       
54266       
54267     } 
54268     goto MATCH_finished_c; 
54269     
54270   MATCH_label_c908: (void)0; /*placeholder for label*/ 
54271     { 
54272       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54273       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54274       nextPC = 8 + MATCH_p; 
54275       
54276 #line 432 "frontend/machine/pentium/decoder.m"
54277       
54278 
54279             stmts = instantiate(pc,  "SHLD.CLod", DIS_EADDR32, DIS_REG32);
54280 
54281       
54282 
54283       
54284       
54285       
54286     } 
54287     goto MATCH_finished_c; 
54288     
54289   MATCH_label_c909: (void)0; /*placeholder for label*/ 
54290     { 
54291       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54292       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54293       nextPC = 7 + MATCH_p; 
54294       
54295 #line 432 "frontend/machine/pentium/decoder.m"
54296       
54297 
54298             stmts = instantiate(pc,  "SHLD.CLod", DIS_EADDR32, DIS_REG32);
54299 
54300       
54301 
54302       
54303       
54304       
54305     } 
54306     goto MATCH_finished_c; 
54307     
54308   MATCH_label_c910: (void)0; /*placeholder for label*/ 
54309     { 
54310       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54311       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54312       nextPC = 3 + MATCH_p; 
54313       
54314 #line 438 "frontend/machine/pentium/decoder.m"
54315       
54316 
54317             stmts = instantiate(pc,  "SHRD.CLod", DIS_EADDR32, DIS_REG32);
54318 
54319       
54320 
54321       
54322       
54323       
54324     } 
54325     goto MATCH_finished_c; 
54326     
54327   MATCH_label_c911: (void)0; /*placeholder for label*/ 
54328     { 
54329       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54330       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54331       nextPC = 4 + MATCH_p; 
54332       
54333 #line 438 "frontend/machine/pentium/decoder.m"
54334       
54335 
54336             stmts = instantiate(pc,  "SHRD.CLod", DIS_EADDR32, DIS_REG32);
54337 
54338       
54339 
54340       
54341       
54342       
54343     } 
54344     goto MATCH_finished_c; 
54345     
54346   MATCH_label_c912: (void)0; /*placeholder for label*/ 
54347     { 
54348       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54349       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54350       nextPC = 8 + MATCH_p; 
54351       
54352 #line 438 "frontend/machine/pentium/decoder.m"
54353       
54354 
54355             stmts = instantiate(pc,  "SHRD.CLod", DIS_EADDR32, DIS_REG32);
54356 
54357       
54358 
54359       
54360       
54361       
54362     } 
54363     goto MATCH_finished_c; 
54364     
54365   MATCH_label_c913: (void)0; /*placeholder for label*/ 
54366     { 
54367       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54368       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54369       nextPC = 7 + MATCH_p; 
54370       
54371 #line 438 "frontend/machine/pentium/decoder.m"
54372       
54373 
54374             stmts = instantiate(pc,  "SHRD.CLod", DIS_EADDR32, DIS_REG32);
54375 
54376       
54377 
54378       
54379       
54380       
54381     } 
54382     goto MATCH_finished_c; 
54383     
54384   MATCH_label_c914: (void)0; /*placeholder for label*/ 
54385     { 
54386       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54387       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54388       nextPC = 3 + MATCH_p; 
54389       
54390 #line 1166 "frontend/machine/pentium/decoder.m"
54391       
54392 
54393             stmts = instantiate(pc,  "IMULrmod", DIS_REG32, DIS_EADDR32);
54394 
54395       
54396 
54397       
54398       
54399       
54400     } 
54401     goto MATCH_finished_c; 
54402     
54403   MATCH_label_c915: (void)0; /*placeholder for label*/ 
54404     { 
54405       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54406       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54407       nextPC = 4 + MATCH_p; 
54408       
54409 #line 1166 "frontend/machine/pentium/decoder.m"
54410       
54411 
54412             stmts = instantiate(pc,  "IMULrmod", DIS_REG32, DIS_EADDR32);
54413 
54414       
54415 
54416       
54417       
54418       
54419     } 
54420     goto MATCH_finished_c; 
54421     
54422   MATCH_label_c916: (void)0; /*placeholder for label*/ 
54423     { 
54424       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54425       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54426       nextPC = 8 + MATCH_p; 
54427       
54428 #line 1166 "frontend/machine/pentium/decoder.m"
54429       
54430 
54431             stmts = instantiate(pc,  "IMULrmod", DIS_REG32, DIS_EADDR32);
54432 
54433       
54434 
54435       
54436       
54437       
54438     } 
54439     goto MATCH_finished_c; 
54440     
54441   MATCH_label_c917: (void)0; /*placeholder for label*/ 
54442     { 
54443       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54444       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54445       nextPC = 7 + MATCH_p; 
54446       
54447 #line 1166 "frontend/machine/pentium/decoder.m"
54448       
54449 
54450             stmts = instantiate(pc,  "IMULrmod", DIS_REG32, DIS_EADDR32);
54451 
54452       
54453 
54454       
54455       
54456       
54457     } 
54458     goto MATCH_finished_c; 
54459     
54460   MATCH_label_c918: (void)0; /*placeholder for label*/ 
54461     { 
54462       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54463       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54464       nextPC = 3 + MATCH_p; 
54465       
54466 #line 1244 "frontend/machine/pentium/decoder.m"
54467       
54468 
54469             stmts = instantiate(pc,  "CMPXCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
54470 
54471       
54472 
54473       
54474       
54475       
54476     } 
54477     goto MATCH_finished_c; 
54478     
54479   MATCH_label_c919: (void)0; /*placeholder for label*/ 
54480     { 
54481       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54482       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54483       nextPC = 4 + MATCH_p; 
54484       
54485 #line 1244 "frontend/machine/pentium/decoder.m"
54486       
54487 
54488             stmts = instantiate(pc,  "CMPXCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
54489 
54490       
54491 
54492       
54493       
54494       
54495     } 
54496     goto MATCH_finished_c; 
54497     
54498   MATCH_label_c920: (void)0; /*placeholder for label*/ 
54499     { 
54500       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54501       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54502       nextPC = 8 + MATCH_p; 
54503       
54504 #line 1244 "frontend/machine/pentium/decoder.m"
54505       
54506 
54507             stmts = instantiate(pc,  "CMPXCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
54508 
54509       
54510 
54511       
54512       
54513       
54514     } 
54515     goto MATCH_finished_c; 
54516     
54517   MATCH_label_c921: (void)0; /*placeholder for label*/ 
54518     { 
54519       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54520       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54521       nextPC = 7 + MATCH_p; 
54522       
54523 #line 1244 "frontend/machine/pentium/decoder.m"
54524       
54525 
54526             stmts = instantiate(pc,  "CMPXCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
54527 
54528       
54529 
54530       
54531       
54532       
54533     } 
54534     goto MATCH_finished_c; 
54535     
54536   MATCH_label_c922: (void)0; /*placeholder for label*/ 
54537     { 
54538       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54539       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54540       nextPC = 3 + MATCH_p; 
54541       
54542 #line 1238 "frontend/machine/pentium/decoder.m"
54543       
54544 
54545             stmts = instantiate(pc,  "CMPXCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
54546 
54547       
54548 
54549       
54550       
54551       
54552     } 
54553     goto MATCH_finished_c; 
54554     
54555   MATCH_label_c923: (void)0; /*placeholder for label*/ 
54556     { 
54557       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54558       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54559       nextPC = 4 + MATCH_p; 
54560       
54561 #line 1238 "frontend/machine/pentium/decoder.m"
54562       
54563 
54564             stmts = instantiate(pc,  "CMPXCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
54565 
54566       
54567 
54568       
54569       
54570       
54571     } 
54572     goto MATCH_finished_c; 
54573     
54574   MATCH_label_c924: (void)0; /*placeholder for label*/ 
54575     { 
54576       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54577       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54578       nextPC = 8 + MATCH_p; 
54579       
54580 #line 1238 "frontend/machine/pentium/decoder.m"
54581       
54582 
54583             stmts = instantiate(pc,  "CMPXCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
54584 
54585       
54586 
54587       
54588       
54589       
54590     } 
54591     goto MATCH_finished_c; 
54592     
54593   MATCH_label_c925: (void)0; /*placeholder for label*/ 
54594     { 
54595       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54596       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54597       nextPC = 7 + MATCH_p; 
54598       
54599 #line 1238 "frontend/machine/pentium/decoder.m"
54600       
54601 
54602             stmts = instantiate(pc,  "CMPXCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
54603 
54604       
54605 
54606       
54607       
54608       
54609     } 
54610     goto MATCH_finished_c; 
54611     
54612   MATCH_label_c926: (void)0; /*placeholder for label*/ 
54613     { 
54614       unsigned Mem = 2 + addressToPC(MATCH_p);
54615       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54616       nextPC = 4 + MATCH_p; 
54617       
54618 #line 1043 "frontend/machine/pentium/decoder.m"
54619       
54620 
54621             stmts = instantiate(pc,  "LSS", DIS_REG32, DIS_MEM);
54622 
54623       
54624 
54625       
54626       
54627       
54628     } 
54629     goto MATCH_finished_c; 
54630     
54631   MATCH_label_c927: (void)0; /*placeholder for label*/ 
54632     { 
54633       unsigned Mem = 2 + addressToPC(MATCH_p);
54634       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54635       nextPC = 8 + MATCH_p; 
54636       
54637 #line 1043 "frontend/machine/pentium/decoder.m"
54638       
54639 
54640             stmts = instantiate(pc,  "LSS", DIS_REG32, DIS_MEM);
54641 
54642       
54643 
54644       
54645       
54646       
54647     } 
54648     goto MATCH_finished_c; 
54649     
54650   MATCH_label_c928: (void)0; /*placeholder for label*/ 
54651     { 
54652       unsigned Mem = 2 + addressToPC(MATCH_p);
54653       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54654       nextPC = 7 + MATCH_p; 
54655       
54656 #line 1043 "frontend/machine/pentium/decoder.m"
54657       
54658 
54659             stmts = instantiate(pc,  "LSS", DIS_REG32, DIS_MEM);
54660 
54661       
54662 
54663       
54664       
54665       
54666     } 
54667     goto MATCH_finished_c; 
54668     
54669   MATCH_label_c929: (void)0; /*placeholder for label*/ 
54670     { 
54671       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54672       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54673       nextPC = 3 + MATCH_p; 
54674       
54675 #line 1328 "frontend/machine/pentium/decoder.m"
54676       
54677 
54678             stmts = instantiate(pc,  "BTRod", DIS_EADDR32, DIS_REG32);
54679 
54680       
54681 
54682       
54683       
54684       
54685     } 
54686     goto MATCH_finished_c; 
54687     
54688   MATCH_label_c930: (void)0; /*placeholder for label*/ 
54689     { 
54690       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54691       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54692       nextPC = 4 + MATCH_p; 
54693       
54694 #line 1328 "frontend/machine/pentium/decoder.m"
54695       
54696 
54697             stmts = instantiate(pc,  "BTRod", DIS_EADDR32, DIS_REG32);
54698 
54699       
54700 
54701       
54702       
54703       
54704     } 
54705     goto MATCH_finished_c; 
54706     
54707   MATCH_label_c931: (void)0; /*placeholder for label*/ 
54708     { 
54709       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54710       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54711       nextPC = 8 + MATCH_p; 
54712       
54713 #line 1328 "frontend/machine/pentium/decoder.m"
54714       
54715 
54716             stmts = instantiate(pc,  "BTRod", DIS_EADDR32, DIS_REG32);
54717 
54718       
54719 
54720       
54721       
54722       
54723     } 
54724     goto MATCH_finished_c; 
54725     
54726   MATCH_label_c932: (void)0; /*placeholder for label*/ 
54727     { 
54728       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54729       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54730       nextPC = 7 + MATCH_p; 
54731       
54732 #line 1328 "frontend/machine/pentium/decoder.m"
54733       
54734 
54735             stmts = instantiate(pc,  "BTRod", DIS_EADDR32, DIS_REG32);
54736 
54737       
54738 
54739       
54740       
54741       
54742     } 
54743     goto MATCH_finished_c; 
54744     
54745   MATCH_label_c933: (void)0; /*placeholder for label*/ 
54746     { 
54747       unsigned Mem = 2 + addressToPC(MATCH_p);
54748       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54749       nextPC = 4 + MATCH_p; 
54750       
54751 #line 1064 "frontend/machine/pentium/decoder.m"
54752       
54753 
54754             stmts = instantiate(pc,  "LFS", DIS_REG32, DIS_MEM);
54755 
54756       
54757 
54758       
54759       
54760       
54761     } 
54762     goto MATCH_finished_c; 
54763     
54764   MATCH_label_c934: (void)0; /*placeholder for label*/ 
54765     { 
54766       unsigned Mem = 2 + addressToPC(MATCH_p);
54767       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54768       nextPC = 8 + MATCH_p; 
54769       
54770 #line 1064 "frontend/machine/pentium/decoder.m"
54771       
54772 
54773             stmts = instantiate(pc,  "LFS", DIS_REG32, DIS_MEM);
54774 
54775       
54776 
54777       
54778       
54779       
54780     } 
54781     goto MATCH_finished_c; 
54782     
54783   MATCH_label_c935: (void)0; /*placeholder for label*/ 
54784     { 
54785       unsigned Mem = 2 + addressToPC(MATCH_p);
54786       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54787       nextPC = 7 + MATCH_p; 
54788       
54789 #line 1064 "frontend/machine/pentium/decoder.m"
54790       
54791 
54792             stmts = instantiate(pc,  "LFS", DIS_REG32, DIS_MEM);
54793 
54794       
54795 
54796       
54797       
54798       
54799     } 
54800     goto MATCH_finished_c; 
54801     
54802   MATCH_label_c936: (void)0; /*placeholder for label*/ 
54803     { 
54804       unsigned Mem = 2 + addressToPC(MATCH_p);
54805       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54806       nextPC = 4 + MATCH_p; 
54807       
54808 #line 1061 "frontend/machine/pentium/decoder.m"
54809       
54810 
54811             stmts = instantiate(pc,  "LGS", DIS_REG32, DIS_MEM);
54812 
54813       
54814 
54815       
54816       
54817       
54818     } 
54819     goto MATCH_finished_c; 
54820     
54821   MATCH_label_c937: (void)0; /*placeholder for label*/ 
54822     { 
54823       unsigned Mem = 2 + addressToPC(MATCH_p);
54824       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54825       nextPC = 8 + MATCH_p; 
54826       
54827 #line 1061 "frontend/machine/pentium/decoder.m"
54828       
54829 
54830             stmts = instantiate(pc,  "LGS", DIS_REG32, DIS_MEM);
54831 
54832       
54833 
54834       
54835       
54836       
54837     } 
54838     goto MATCH_finished_c; 
54839     
54840   MATCH_label_c938: (void)0; /*placeholder for label*/ 
54841     { 
54842       unsigned Mem = 2 + addressToPC(MATCH_p);
54843       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54844       nextPC = 7 + MATCH_p; 
54845       
54846 #line 1061 "frontend/machine/pentium/decoder.m"
54847       
54848 
54849             stmts = instantiate(pc,  "LGS", DIS_REG32, DIS_MEM);
54850 
54851       
54852 
54853       
54854       
54855       
54856     } 
54857     goto MATCH_finished_c; 
54858     
54859   MATCH_label_c939: (void)0; /*placeholder for label*/ 
54860     { 
54861       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54862       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54863       nextPC = 3 + MATCH_p; 
54864       
54865 #line 940 "frontend/machine/pentium/decoder.m"
54866       
54867 
54868             stmts = instantiate(pc,  "MOVZX.Gv.Ebod", DIS_R32, DIS_EADDR8);
54869 
54870       
54871 
54872       
54873       
54874       
54875     } 
54876     goto MATCH_finished_c; 
54877     
54878   MATCH_label_c940: (void)0; /*placeholder for label*/ 
54879     { 
54880       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54881       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54882       nextPC = 4 + MATCH_p; 
54883       
54884 #line 940 "frontend/machine/pentium/decoder.m"
54885       
54886 
54887             stmts = instantiate(pc,  "MOVZX.Gv.Ebod", DIS_R32, DIS_EADDR8);
54888 
54889       
54890 
54891       
54892       
54893       
54894     } 
54895     goto MATCH_finished_c; 
54896     
54897   MATCH_label_c941: (void)0; /*placeholder for label*/ 
54898     { 
54899       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54900       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54901       nextPC = 8 + MATCH_p; 
54902       
54903 #line 940 "frontend/machine/pentium/decoder.m"
54904       
54905 
54906             stmts = instantiate(pc,  "MOVZX.Gv.Ebod", DIS_R32, DIS_EADDR8);
54907 
54908       
54909 
54910       
54911       
54912       
54913     } 
54914     goto MATCH_finished_c; 
54915     
54916   MATCH_label_c942: (void)0; /*placeholder for label*/ 
54917     { 
54918       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54919       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54920       nextPC = 7 + MATCH_p; 
54921       
54922 #line 940 "frontend/machine/pentium/decoder.m"
54923       
54924 
54925             stmts = instantiate(pc,  "MOVZX.Gv.Ebod", DIS_R32, DIS_EADDR8);
54926 
54927       
54928 
54929       
54930       
54931       
54932     } 
54933     goto MATCH_finished_c; 
54934     
54935   MATCH_label_c943: (void)0; /*placeholder for label*/ 
54936     { 
54937       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54938       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54939       nextPC = 3 + MATCH_p; 
54940       
54941 #line 937 "frontend/machine/pentium/decoder.m"
54942       
54943 
54944             stmts = instantiate(pc,  "MOVZX.Gv.Ew", DIS_R32, DIS_EADDR16);
54945 
54946       
54947 
54948       
54949       
54950       
54951     } 
54952     goto MATCH_finished_c; 
54953     
54954   MATCH_label_c944: (void)0; /*placeholder for label*/ 
54955     { 
54956       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54957       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54958       nextPC = 4 + MATCH_p; 
54959       
54960 #line 937 "frontend/machine/pentium/decoder.m"
54961       
54962 
54963             stmts = instantiate(pc,  "MOVZX.Gv.Ew", DIS_R32, DIS_EADDR16);
54964 
54965       
54966 
54967       
54968       
54969       
54970     } 
54971     goto MATCH_finished_c; 
54972     
54973   MATCH_label_c945: (void)0; /*placeholder for label*/ 
54974     { 
54975       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54976       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54977       nextPC = 8 + MATCH_p; 
54978       
54979 #line 937 "frontend/machine/pentium/decoder.m"
54980       
54981 
54982             stmts = instantiate(pc,  "MOVZX.Gv.Ew", DIS_R32, DIS_EADDR16);
54983 
54984       
54985 
54986       
54987       
54988       
54989     } 
54990     goto MATCH_finished_c; 
54991     
54992   MATCH_label_c946: (void)0; /*placeholder for label*/ 
54993     { 
54994       unsigned Eaddr = 2 + addressToPC(MATCH_p);
54995       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
54996       nextPC = 7 + MATCH_p; 
54997       
54998 #line 937 "frontend/machine/pentium/decoder.m"
54999       
55000 
55001             stmts = instantiate(pc,  "MOVZX.Gv.Ew", DIS_R32, DIS_EADDR16);
55002 
55003       
55004 
55005       
55006       
55007       
55008     } 
55009     goto MATCH_finished_c; 
55010     
55011   MATCH_label_c947: (void)0; /*placeholder for label*/ 
55012     { 
55013       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55014       int /* [~128..127] */ i8 = 
55015         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
55016       nextPC = 4 + MATCH_p; 
55017       
55018 #line 1346 "frontend/machine/pentium/decoder.m"
55019       
55020 
55021             stmts = instantiate(pc,  "BTiod", DIS_EADDR32, DIS_I8);
55022 
55023       
55024 
55025       
55026       
55027       
55028     } 
55029     goto MATCH_finished_c; 
55030     
55031   MATCH_label_c948: (void)0; /*placeholder for label*/ 
55032     { 
55033       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55034       int /* [~128..127] */ i8 = 
55035         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
55036       nextPC = 5 + MATCH_p; 
55037       
55038 #line 1346 "frontend/machine/pentium/decoder.m"
55039       
55040 
55041             stmts = instantiate(pc,  "BTiod", DIS_EADDR32, DIS_I8);
55042 
55043       
55044 
55045       
55046       
55047       
55048     } 
55049     goto MATCH_finished_c; 
55050     
55051   MATCH_label_c949: (void)0; /*placeholder for label*/ 
55052     { 
55053       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55054       int /* [~128..127] */ i8 = 
55055         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
55056       nextPC = 9 + MATCH_p; 
55057       
55058 #line 1346 "frontend/machine/pentium/decoder.m"
55059       
55060 
55061             stmts = instantiate(pc,  "BTiod", DIS_EADDR32, DIS_I8);
55062 
55063       
55064 
55065       
55066       
55067       
55068     } 
55069     goto MATCH_finished_c; 
55070     
55071   MATCH_label_c950: (void)0; /*placeholder for label*/ 
55072     { 
55073       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55074       int /* [~128..127] */ i8 = 
55075         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
55076       nextPC = 8 + MATCH_p; 
55077       
55078 #line 1346 "frontend/machine/pentium/decoder.m"
55079       
55080 
55081             stmts = instantiate(pc,  "BTiod", DIS_EADDR32, DIS_I8);
55082 
55083       
55084 
55085       
55086       
55087       
55088     } 
55089     goto MATCH_finished_c; 
55090     
55091   MATCH_label_c951: (void)0; /*placeholder for label*/ 
55092     { 
55093       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55094       int /* [~128..127] */ i8 = 
55095         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
55096       nextPC = 4 + MATCH_p; 
55097       
55098 #line 1310 "frontend/machine/pentium/decoder.m"
55099       
55100 
55101             stmts = instantiate(pc,  "BTSiod", DIS_I8, DIS_EADDR32);
55102 
55103       
55104 
55105       
55106       
55107       
55108     } 
55109     goto MATCH_finished_c; 
55110     
55111   MATCH_label_c952: (void)0; /*placeholder for label*/ 
55112     { 
55113       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55114       int /* [~128..127] */ i8 = 
55115         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
55116       nextPC = 5 + MATCH_p; 
55117       
55118 #line 1310 "frontend/machine/pentium/decoder.m"
55119       
55120 
55121             stmts = instantiate(pc,  "BTSiod", DIS_I8, DIS_EADDR32);
55122 
55123       
55124 
55125       
55126       
55127       
55128     } 
55129     goto MATCH_finished_c; 
55130     
55131   MATCH_label_c953: (void)0; /*placeholder for label*/ 
55132     { 
55133       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55134       int /* [~128..127] */ i8 = 
55135         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
55136       nextPC = 9 + MATCH_p; 
55137       
55138 #line 1310 "frontend/machine/pentium/decoder.m"
55139       
55140 
55141             stmts = instantiate(pc,  "BTSiod", DIS_I8, DIS_EADDR32);
55142 
55143       
55144 
55145       
55146       
55147       
55148     } 
55149     goto MATCH_finished_c; 
55150     
55151   MATCH_label_c954: (void)0; /*placeholder for label*/ 
55152     { 
55153       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55154       int /* [~128..127] */ i8 = 
55155         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
55156       nextPC = 8 + MATCH_p; 
55157       
55158 #line 1310 "frontend/machine/pentium/decoder.m"
55159       
55160 
55161             stmts = instantiate(pc,  "BTSiod", DIS_I8, DIS_EADDR32);
55162 
55163       
55164 
55165       
55166       
55167       
55168     } 
55169     goto MATCH_finished_c; 
55170     
55171   MATCH_label_c955: (void)0; /*placeholder for label*/ 
55172     { 
55173       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55174       int /* [~128..127] */ i8 = 
55175         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
55176       nextPC = 4 + MATCH_p; 
55177       
55178 #line 1322 "frontend/machine/pentium/decoder.m"
55179       
55180 
55181             stmts = instantiate(pc,  "BTRiod", DIS_EADDR32, DIS_I8);
55182 
55183       
55184 
55185       
55186       
55187       
55188     } 
55189     goto MATCH_finished_c; 
55190     
55191   MATCH_label_c956: (void)0; /*placeholder for label*/ 
55192     { 
55193       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55194       int /* [~128..127] */ i8 = 
55195         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
55196       nextPC = 5 + MATCH_p; 
55197       
55198 #line 1322 "frontend/machine/pentium/decoder.m"
55199       
55200 
55201             stmts = instantiate(pc,  "BTRiod", DIS_EADDR32, DIS_I8);
55202 
55203       
55204 
55205       
55206       
55207       
55208     } 
55209     goto MATCH_finished_c; 
55210     
55211   MATCH_label_c957: (void)0; /*placeholder for label*/ 
55212     { 
55213       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55214       int /* [~128..127] */ i8 = 
55215         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
55216       nextPC = 9 + MATCH_p; 
55217       
55218 #line 1322 "frontend/machine/pentium/decoder.m"
55219       
55220 
55221             stmts = instantiate(pc,  "BTRiod", DIS_EADDR32, DIS_I8);
55222 
55223       
55224 
55225       
55226       
55227       
55228     } 
55229     goto MATCH_finished_c; 
55230     
55231   MATCH_label_c958: (void)0; /*placeholder for label*/ 
55232     { 
55233       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55234       int /* [~128..127] */ i8 = 
55235         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
55236       nextPC = 8 + MATCH_p; 
55237       
55238 #line 1322 "frontend/machine/pentium/decoder.m"
55239       
55240 
55241             stmts = instantiate(pc,  "BTRiod", DIS_EADDR32, DIS_I8);
55242 
55243       
55244 
55245       
55246       
55247       
55248     } 
55249     goto MATCH_finished_c; 
55250     
55251   MATCH_label_c959: (void)0; /*placeholder for label*/ 
55252     { 
55253       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55254       int /* [~128..127] */ i8 = 
55255         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
55256       nextPC = 4 + MATCH_p; 
55257       
55258 #line 1334 "frontend/machine/pentium/decoder.m"
55259       
55260 
55261             stmts = instantiate(pc,  "BTCiod", DIS_EADDR32, DIS_I8);
55262 
55263       
55264 
55265       
55266       
55267       
55268     } 
55269     goto MATCH_finished_c; 
55270     
55271   MATCH_label_c960: (void)0; /*placeholder for label*/ 
55272     { 
55273       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55274       int /* [~128..127] */ i8 = 
55275         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
55276       nextPC = 5 + MATCH_p; 
55277       
55278 #line 1334 "frontend/machine/pentium/decoder.m"
55279       
55280 
55281             stmts = instantiate(pc,  "BTCiod", DIS_EADDR32, DIS_I8);
55282 
55283       
55284 
55285       
55286       
55287       
55288     } 
55289     goto MATCH_finished_c; 
55290     
55291   MATCH_label_c961: (void)0; /*placeholder for label*/ 
55292     { 
55293       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55294       int /* [~128..127] */ i8 = 
55295         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
55296       nextPC = 9 + MATCH_p; 
55297       
55298 #line 1334 "frontend/machine/pentium/decoder.m"
55299       
55300 
55301             stmts = instantiate(pc,  "BTCiod", DIS_EADDR32, DIS_I8);
55302 
55303       
55304 
55305       
55306       
55307       
55308     } 
55309     goto MATCH_finished_c; 
55310     
55311   MATCH_label_c962: (void)0; /*placeholder for label*/ 
55312     { 
55313       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55314       int /* [~128..127] */ i8 = 
55315         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
55316       nextPC = 8 + MATCH_p; 
55317       
55318 #line 1334 "frontend/machine/pentium/decoder.m"
55319       
55320 
55321             stmts = instantiate(pc,  "BTCiod", DIS_EADDR32, DIS_I8);
55322 
55323       
55324 
55325       
55326       
55327       
55328     } 
55329     goto MATCH_finished_c; 
55330     
55331   MATCH_label_c963: (void)0; /*placeholder for label*/ 
55332     { 
55333       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55334       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55335       nextPC = 3 + MATCH_p; 
55336       
55337 #line 1340 "frontend/machine/pentium/decoder.m"
55338       
55339 
55340             stmts = instantiate(pc,  "BTCod", DIS_EADDR32, DIS_REG32);
55341 
55342       
55343 
55344       
55345       
55346       
55347     } 
55348     goto MATCH_finished_c; 
55349     
55350   MATCH_label_c964: (void)0; /*placeholder for label*/ 
55351     { 
55352       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55353       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55354       nextPC = 4 + MATCH_p; 
55355       
55356 #line 1340 "frontend/machine/pentium/decoder.m"
55357       
55358 
55359             stmts = instantiate(pc,  "BTCod", DIS_EADDR32, DIS_REG32);
55360 
55361       
55362 
55363       
55364       
55365       
55366     } 
55367     goto MATCH_finished_c; 
55368     
55369   MATCH_label_c965: (void)0; /*placeholder for label*/ 
55370     { 
55371       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55372       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55373       nextPC = 8 + MATCH_p; 
55374       
55375 #line 1340 "frontend/machine/pentium/decoder.m"
55376       
55377 
55378             stmts = instantiate(pc,  "BTCod", DIS_EADDR32, DIS_REG32);
55379 
55380       
55381 
55382       
55383       
55384       
55385     } 
55386     goto MATCH_finished_c; 
55387     
55388   MATCH_label_c966: (void)0; /*placeholder for label*/ 
55389     { 
55390       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55391       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55392       nextPC = 7 + MATCH_p; 
55393       
55394 #line 1340 "frontend/machine/pentium/decoder.m"
55395       
55396 
55397             stmts = instantiate(pc,  "BTCod", DIS_EADDR32, DIS_REG32);
55398 
55399       
55400 
55401       
55402       
55403       
55404     } 
55405     goto MATCH_finished_c; 
55406     
55407   MATCH_label_c967: (void)0; /*placeholder for label*/ 
55408     { 
55409       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55410       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55411       nextPC = 3 + MATCH_p; 
55412       
55413 #line 1372 "frontend/machine/pentium/decoder.m"
55414       
55415 
55416             //stmts = instantiate(pc,  "BSFod", DIS_REG32, DIS_EADDR32);
55417 
55418             genBSFR(pc, DIS_REG32, DIS_EADDR32, -1, 32, opPlus, nextPC-hostPC);
55419 
55420             return result;
55421 
55422       
55423 
55424       
55425       
55426       
55427     } 
55428     goto MATCH_finished_c; 
55429     
55430   MATCH_label_c968: (void)0; /*placeholder for label*/ 
55431     { 
55432       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55433       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55434       nextPC = 4 + MATCH_p; 
55435       
55436 #line 1372 "frontend/machine/pentium/decoder.m"
55437       
55438 
55439             //stmts = instantiate(pc,  "BSFod", DIS_REG32, DIS_EADDR32);
55440 
55441             genBSFR(pc, DIS_REG32, DIS_EADDR32, -1, 32, opPlus, nextPC-hostPC);
55442 
55443             return result;
55444 
55445       
55446 
55447       
55448       
55449       
55450     } 
55451     goto MATCH_finished_c; 
55452     
55453   MATCH_label_c969: (void)0; /*placeholder for label*/ 
55454     { 
55455       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55456       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55457       nextPC = 8 + MATCH_p; 
55458       
55459 #line 1372 "frontend/machine/pentium/decoder.m"
55460       
55461 
55462             //stmts = instantiate(pc,  "BSFod", DIS_REG32, DIS_EADDR32);
55463 
55464             genBSFR(pc, DIS_REG32, DIS_EADDR32, -1, 32, opPlus, nextPC-hostPC);
55465 
55466             return result;
55467 
55468       
55469 
55470       
55471       
55472       
55473     } 
55474     goto MATCH_finished_c; 
55475     
55476   MATCH_label_c970: (void)0; /*placeholder for label*/ 
55477     { 
55478       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55479       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55480       nextPC = 7 + MATCH_p; 
55481       
55482 #line 1372 "frontend/machine/pentium/decoder.m"
55483       
55484 
55485             //stmts = instantiate(pc,  "BSFod", DIS_REG32, DIS_EADDR32);
55486 
55487             genBSFR(pc, DIS_REG32, DIS_EADDR32, -1, 32, opPlus, nextPC-hostPC);
55488 
55489             return result;
55490 
55491       
55492 
55493       
55494       
55495       
55496     } 
55497     goto MATCH_finished_c; 
55498     
55499   MATCH_label_c971: (void)0; /*placeholder for label*/ 
55500     { 
55501       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55502       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55503       nextPC = 3 + MATCH_p; 
55504       
55505 #line 1361 "frontend/machine/pentium/decoder.m"
55506       
55507 
55508             //stmts = instantiate(pc,  "BSRod", DIS_REG32, DIS_EADDR32);
55509 
55510             // Bit Scan Forward: need helper function
55511 
55512             genBSFR(pc, DIS_REG32, DIS_EADDR32, 32, 32, opMinus, nextPC-hostPC);
55513 
55514             return result;
55515 
55516       
55517 
55518       
55519       
55520       
55521     } 
55522     goto MATCH_finished_c; 
55523     
55524   MATCH_label_c972: (void)0; /*placeholder for label*/ 
55525     { 
55526       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55527       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55528       nextPC = 4 + MATCH_p; 
55529       
55530 #line 1361 "frontend/machine/pentium/decoder.m"
55531       
55532 
55533             //stmts = instantiate(pc,  "BSRod", DIS_REG32, DIS_EADDR32);
55534 
55535             // Bit Scan Forward: need helper function
55536 
55537             genBSFR(pc, DIS_REG32, DIS_EADDR32, 32, 32, opMinus, nextPC-hostPC);
55538 
55539             return result;
55540 
55541       
55542 
55543       
55544       
55545       
55546     } 
55547     goto MATCH_finished_c; 
55548     
55549   MATCH_label_c973: (void)0; /*placeholder for label*/ 
55550     { 
55551       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55552       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55553       nextPC = 8 + MATCH_p; 
55554       
55555 #line 1361 "frontend/machine/pentium/decoder.m"
55556       
55557 
55558             //stmts = instantiate(pc,  "BSRod", DIS_REG32, DIS_EADDR32);
55559 
55560             // Bit Scan Forward: need helper function
55561 
55562             genBSFR(pc, DIS_REG32, DIS_EADDR32, 32, 32, opMinus, nextPC-hostPC);
55563 
55564             return result;
55565 
55566       
55567 
55568       
55569       
55570       
55571     } 
55572     goto MATCH_finished_c; 
55573     
55574   MATCH_label_c974: (void)0; /*placeholder for label*/ 
55575     { 
55576       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55577       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55578       nextPC = 7 + MATCH_p; 
55579       
55580 #line 1361 "frontend/machine/pentium/decoder.m"
55581       
55582 
55583             //stmts = instantiate(pc,  "BSRod", DIS_REG32, DIS_EADDR32);
55584 
55585             // Bit Scan Forward: need helper function
55586 
55587             genBSFR(pc, DIS_REG32, DIS_EADDR32, 32, 32, opMinus, nextPC-hostPC);
55588 
55589             return result;
55590 
55591       
55592 
55593       
55594       
55595       
55596     } 
55597     goto MATCH_finished_c; 
55598     
55599   MATCH_label_c975: (void)0; /*placeholder for label*/ 
55600     { 
55601       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55602       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55603       nextPC = 3 + MATCH_p; 
55604       
55605 #line 949 "frontend/machine/pentium/decoder.m"
55606       
55607 
55608             stmts = instantiate(pc,  "MOVSX.Gv.Ebod", DIS_R32, DIS_EADDR8);
55609 
55610       
55611 
55612       
55613       
55614       
55615     } 
55616     goto MATCH_finished_c; 
55617     
55618   MATCH_label_c976: (void)0; /*placeholder for label*/ 
55619     { 
55620       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55621       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55622       nextPC = 4 + MATCH_p; 
55623       
55624 #line 949 "frontend/machine/pentium/decoder.m"
55625       
55626 
55627             stmts = instantiate(pc,  "MOVSX.Gv.Ebod", DIS_R32, DIS_EADDR8);
55628 
55629       
55630 
55631       
55632       
55633       
55634     } 
55635     goto MATCH_finished_c; 
55636     
55637   MATCH_label_c977: (void)0; /*placeholder for label*/ 
55638     { 
55639       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55640       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55641       nextPC = 8 + MATCH_p; 
55642       
55643 #line 949 "frontend/machine/pentium/decoder.m"
55644       
55645 
55646             stmts = instantiate(pc,  "MOVSX.Gv.Ebod", DIS_R32, DIS_EADDR8);
55647 
55648       
55649 
55650       
55651       
55652       
55653     } 
55654     goto MATCH_finished_c; 
55655     
55656   MATCH_label_c978: (void)0; /*placeholder for label*/ 
55657     { 
55658       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55659       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55660       nextPC = 7 + MATCH_p; 
55661       
55662 #line 949 "frontend/machine/pentium/decoder.m"
55663       
55664 
55665             stmts = instantiate(pc,  "MOVSX.Gv.Ebod", DIS_R32, DIS_EADDR8);
55666 
55667       
55668 
55669       
55670       
55671       
55672     } 
55673     goto MATCH_finished_c; 
55674     
55675   MATCH_label_c979: (void)0; /*placeholder for label*/ 
55676     { 
55677       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55678       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55679       nextPC = 3 + MATCH_p; 
55680       
55681 #line 946 "frontend/machine/pentium/decoder.m"
55682       
55683 
55684             stmts = instantiate(pc,  "MOVSX.Gv.Ew", DIS_R32, DIS_EADDR16);
55685 
55686       
55687 
55688       
55689       
55690       
55691     } 
55692     goto MATCH_finished_c; 
55693     
55694   MATCH_label_c980: (void)0; /*placeholder for label*/ 
55695     { 
55696       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55697       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55698       nextPC = 4 + MATCH_p; 
55699       
55700 #line 946 "frontend/machine/pentium/decoder.m"
55701       
55702 
55703             stmts = instantiate(pc,  "MOVSX.Gv.Ew", DIS_R32, DIS_EADDR16);
55704 
55705       
55706 
55707       
55708       
55709       
55710     } 
55711     goto MATCH_finished_c; 
55712     
55713   MATCH_label_c981: (void)0; /*placeholder for label*/ 
55714     { 
55715       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55716       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55717       nextPC = 8 + MATCH_p; 
55718       
55719 #line 946 "frontend/machine/pentium/decoder.m"
55720       
55721 
55722             stmts = instantiate(pc,  "MOVSX.Gv.Ew", DIS_R32, DIS_EADDR16);
55723 
55724       
55725 
55726       
55727       
55728       
55729     } 
55730     goto MATCH_finished_c; 
55731     
55732   MATCH_label_c982: (void)0; /*placeholder for label*/ 
55733     { 
55734       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55735       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55736       nextPC = 7 + MATCH_p; 
55737       
55738 #line 946 "frontend/machine/pentium/decoder.m"
55739       
55740 
55741             stmts = instantiate(pc,  "MOVSX.Gv.Ew", DIS_R32, DIS_EADDR16);
55742 
55743       
55744 
55745       
55746       
55747       
55748     } 
55749     goto MATCH_finished_c; 
55750     
55751   MATCH_label_c983: (void)0; /*placeholder for label*/ 
55752     { 
55753       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55754       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55755       nextPC = 3 + MATCH_p; 
55756       
55757 #line 360 "frontend/machine/pentium/decoder.m"
55758       
55759 
55760             stmts = instantiate(pc,  "XADD.Eb.Gb", DIS_EADDR8, DIS_REG8);
55761 
55762       
55763 
55764       
55765       
55766       
55767     } 
55768     goto MATCH_finished_c; 
55769     
55770   MATCH_label_c984: (void)0; /*placeholder for label*/ 
55771     { 
55772       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55773       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55774       nextPC = 4 + MATCH_p; 
55775       
55776 #line 360 "frontend/machine/pentium/decoder.m"
55777       
55778 
55779             stmts = instantiate(pc,  "XADD.Eb.Gb", DIS_EADDR8, DIS_REG8);
55780 
55781       
55782 
55783       
55784       
55785       
55786     } 
55787     goto MATCH_finished_c; 
55788     
55789   MATCH_label_c985: (void)0; /*placeholder for label*/ 
55790     { 
55791       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55792       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55793       nextPC = 8 + MATCH_p; 
55794       
55795 #line 360 "frontend/machine/pentium/decoder.m"
55796       
55797 
55798             stmts = instantiate(pc,  "XADD.Eb.Gb", DIS_EADDR8, DIS_REG8);
55799 
55800       
55801 
55802       
55803       
55804       
55805     } 
55806     goto MATCH_finished_c; 
55807     
55808   MATCH_label_c986: (void)0; /*placeholder for label*/ 
55809     { 
55810       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55811       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55812       nextPC = 7 + MATCH_p; 
55813       
55814 #line 360 "frontend/machine/pentium/decoder.m"
55815       
55816 
55817             stmts = instantiate(pc,  "XADD.Eb.Gb", DIS_EADDR8, DIS_REG8);
55818 
55819       
55820 
55821       
55822       
55823       
55824     } 
55825     goto MATCH_finished_c; 
55826     
55827   MATCH_label_c987: (void)0; /*placeholder for label*/ 
55828     { 
55829       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55830       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55831       nextPC = 3 + MATCH_p; 
55832       
55833 #line 354 "frontend/machine/pentium/decoder.m"
55834       
55835 
55836             stmts = instantiate(pc,  "XADD.Ev.Gvod", DIS_EADDR32, DIS_REG32);
55837 
55838       
55839 
55840       
55841       
55842       
55843     } 
55844     goto MATCH_finished_c; 
55845     
55846   MATCH_label_c988: (void)0; /*placeholder for label*/ 
55847     { 
55848       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55849       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55850       nextPC = 4 + MATCH_p; 
55851       
55852 #line 354 "frontend/machine/pentium/decoder.m"
55853       
55854 
55855             stmts = instantiate(pc,  "XADD.Ev.Gvod", DIS_EADDR32, DIS_REG32);
55856 
55857       
55858 
55859       
55860       
55861       
55862     } 
55863     goto MATCH_finished_c; 
55864     
55865   MATCH_label_c989: (void)0; /*placeholder for label*/ 
55866     { 
55867       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55868       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55869       nextPC = 8 + MATCH_p; 
55870       
55871 #line 354 "frontend/machine/pentium/decoder.m"
55872       
55873 
55874             stmts = instantiate(pc,  "XADD.Ev.Gvod", DIS_EADDR32, DIS_REG32);
55875 
55876       
55877 
55878       
55879       
55880       
55881     } 
55882     goto MATCH_finished_c; 
55883     
55884   MATCH_label_c990: (void)0; /*placeholder for label*/ 
55885     { 
55886       unsigned Eaddr = 2 + addressToPC(MATCH_p);
55887       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
55888       nextPC = 7 + MATCH_p; 
55889       
55890 #line 354 "frontend/machine/pentium/decoder.m"
55891       
55892 
55893             stmts = instantiate(pc,  "XADD.Ev.Gvod", DIS_EADDR32, DIS_REG32);
55894 
55895       
55896 
55897       
55898       
55899       
55900     } 
55901     goto MATCH_finished_c; 
55902     
55903   MATCH_label_c991: (void)0; /*placeholder for label*/ 
55904     { 
55905       unsigned Mem = 2 + addressToPC(MATCH_p);
55906       nextPC = 4 + MATCH_p; 
55907       
55908 #line 1235 "frontend/machine/pentium/decoder.m"
55909       
55910 
55911             stmts = instantiate(pc,  "CMPXCHG8B", DIS_MEM);
55912 
55913       
55914 
55915       
55916       
55917       
55918     } 
55919     goto MATCH_finished_c; 
55920     
55921   MATCH_label_c992: (void)0; /*placeholder for label*/ 
55922     { 
55923       unsigned Mem = 2 + addressToPC(MATCH_p);
55924       nextPC = 8 + MATCH_p; 
55925       
55926 #line 1235 "frontend/machine/pentium/decoder.m"
55927       
55928 
55929             stmts = instantiate(pc,  "CMPXCHG8B", DIS_MEM);
55930 
55931       
55932 
55933       
55934       
55935       
55936     } 
55937     goto MATCH_finished_c; 
55938     
55939   MATCH_label_c993: (void)0; /*placeholder for label*/ 
55940     { 
55941       unsigned Mem = 2 + addressToPC(MATCH_p);
55942       nextPC = 7 + MATCH_p; 
55943       
55944 #line 1235 "frontend/machine/pentium/decoder.m"
55945       
55946 
55947             stmts = instantiate(pc,  "CMPXCHG8B", DIS_MEM);
55948 
55949       
55950 
55951       
55952       
55953       
55954     } 
55955     goto MATCH_finished_c; 
55956     
55957   MATCH_label_c994: (void)0; /*placeholder for label*/ 
55958     { 
55959       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55960       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
55961       nextPC = 2 + MATCH_p; 
55962       
55963 #line 1537 "frontend/machine/pentium/decoder.m"
55964       
55965 
55966             stmts = instantiate(pc,  "SBBmrb", DIS_EADDR8, DIS_R8);
55967 
55968       
55969 
55970       
55971       
55972       
55973     } 
55974     goto MATCH_finished_c; 
55975     
55976   MATCH_label_c995: (void)0; /*placeholder for label*/ 
55977     { 
55978       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55979       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
55980       nextPC = 3 + MATCH_p; 
55981       
55982 #line 1537 "frontend/machine/pentium/decoder.m"
55983       
55984 
55985             stmts = instantiate(pc,  "SBBmrb", DIS_EADDR8, DIS_R8);
55986 
55987       
55988 
55989       
55990       
55991       
55992     } 
55993     goto MATCH_finished_c; 
55994     
55995   MATCH_label_c996: (void)0; /*placeholder for label*/ 
55996     { 
55997       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55998       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
55999       nextPC = 7 + MATCH_p; 
56000       
56001 #line 1537 "frontend/machine/pentium/decoder.m"
56002       
56003 
56004             stmts = instantiate(pc,  "SBBmrb", DIS_EADDR8, DIS_R8);
56005 
56006       
56007 
56008       
56009       
56010       
56011     } 
56012     goto MATCH_finished_c; 
56013     
56014   MATCH_label_c997: (void)0; /*placeholder for label*/ 
56015     { 
56016       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56017       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56018       nextPC = 6 + MATCH_p; 
56019       
56020 #line 1537 "frontend/machine/pentium/decoder.m"
56021       
56022 
56023             stmts = instantiate(pc,  "SBBmrb", DIS_EADDR8, DIS_R8);
56024 
56025       
56026 
56027       
56028       
56029       
56030     } 
56031     goto MATCH_finished_c; 
56032     
56033   MATCH_label_c998: (void)0; /*placeholder for label*/ 
56034     { 
56035       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56036       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56037       nextPC = 2 + MATCH_p; 
56038       
56039 #line 1501 "frontend/machine/pentium/decoder.m"
56040       
56041 
56042             stmts = instantiate(pc,  "SBBmrod", DIS_EADDR32, DIS_REG32);
56043 
56044       
56045 
56046       
56047       
56048       
56049     } 
56050     goto MATCH_finished_c; 
56051     
56052   MATCH_label_c999: (void)0; /*placeholder for label*/ 
56053     { 
56054       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56055       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56056       nextPC = 3 + MATCH_p; 
56057       
56058 #line 1501 "frontend/machine/pentium/decoder.m"
56059       
56060 
56061             stmts = instantiate(pc,  "SBBmrod", DIS_EADDR32, DIS_REG32);
56062 
56063       
56064 
56065       
56066       
56067       
56068     } 
56069     goto MATCH_finished_c; 
56070     
56071   MATCH_label_c1000: (void)0; /*placeholder for label*/ 
56072     { 
56073       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56074       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56075       nextPC = 7 + MATCH_p; 
56076       
56077 #line 1501 "frontend/machine/pentium/decoder.m"
56078       
56079 
56080             stmts = instantiate(pc,  "SBBmrod", DIS_EADDR32, DIS_REG32);
56081 
56082       
56083 
56084       
56085       
56086       
56087     } 
56088     goto MATCH_finished_c; 
56089     
56090   MATCH_label_c1001: (void)0; /*placeholder for label*/ 
56091     { 
56092       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56093       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56094       nextPC = 6 + MATCH_p; 
56095       
56096 #line 1501 "frontend/machine/pentium/decoder.m"
56097       
56098 
56099             stmts = instantiate(pc,  "SBBmrod", DIS_EADDR32, DIS_REG32);
56100 
56101       
56102 
56103       
56104       
56105       
56106     } 
56107     goto MATCH_finished_c; 
56108     
56109   MATCH_label_c1002: (void)0; /*placeholder for label*/ 
56110     { 
56111       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56112       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56113       nextPC = 2 + MATCH_p; 
56114       
56115 #line 1465 "frontend/machine/pentium/decoder.m"
56116       
56117 
56118             stmts = instantiate(pc,  "SBBrmb", DIS_R8, DIS_EADDR8);
56119 
56120       
56121 
56122       
56123       
56124       
56125     } 
56126     goto MATCH_finished_c; 
56127     
56128   MATCH_label_c1003: (void)0; /*placeholder for label*/ 
56129     { 
56130       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56131       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56132       nextPC = 3 + MATCH_p; 
56133       
56134 #line 1465 "frontend/machine/pentium/decoder.m"
56135       
56136 
56137             stmts = instantiate(pc,  "SBBrmb", DIS_R8, DIS_EADDR8);
56138 
56139       
56140 
56141       
56142       
56143       
56144     } 
56145     goto MATCH_finished_c; 
56146     
56147   MATCH_label_c1004: (void)0; /*placeholder for label*/ 
56148     { 
56149       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56150       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56151       nextPC = 7 + MATCH_p; 
56152       
56153 #line 1465 "frontend/machine/pentium/decoder.m"
56154       
56155 
56156             stmts = instantiate(pc,  "SBBrmb", DIS_R8, DIS_EADDR8);
56157 
56158       
56159 
56160       
56161       
56162       
56163     } 
56164     goto MATCH_finished_c; 
56165     
56166   MATCH_label_c1005: (void)0; /*placeholder for label*/ 
56167     { 
56168       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56169       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56170       nextPC = 6 + MATCH_p; 
56171       
56172 #line 1465 "frontend/machine/pentium/decoder.m"
56173       
56174 
56175             stmts = instantiate(pc,  "SBBrmb", DIS_R8, DIS_EADDR8);
56176 
56177       
56178 
56179       
56180       
56181       
56182     } 
56183     goto MATCH_finished_c; 
56184     
56185   MATCH_label_c1006: (void)0; /*placeholder for label*/ 
56186     { 
56187       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56188       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56189       nextPC = 2 + MATCH_p; 
56190       
56191 #line 1429 "frontend/machine/pentium/decoder.m"
56192       
56193 
56194             stmts = instantiate(pc,  "SBBrmod", DIS_REG32, DIS_EADDR32);
56195 
56196       
56197 
56198       
56199       
56200       
56201     } 
56202     goto MATCH_finished_c; 
56203     
56204   MATCH_label_c1007: (void)0; /*placeholder for label*/ 
56205     { 
56206       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56207       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56208       nextPC = 3 + MATCH_p; 
56209       
56210 #line 1429 "frontend/machine/pentium/decoder.m"
56211       
56212 
56213             stmts = instantiate(pc,  "SBBrmod", DIS_REG32, DIS_EADDR32);
56214 
56215       
56216 
56217       
56218       
56219       
56220     } 
56221     goto MATCH_finished_c; 
56222     
56223   MATCH_label_c1008: (void)0; /*placeholder for label*/ 
56224     { 
56225       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56226       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56227       nextPC = 7 + MATCH_p; 
56228       
56229 #line 1429 "frontend/machine/pentium/decoder.m"
56230       
56231 
56232             stmts = instantiate(pc,  "SBBrmod", DIS_REG32, DIS_EADDR32);
56233 
56234       
56235 
56236       
56237       
56238       
56239     } 
56240     goto MATCH_finished_c; 
56241     
56242   MATCH_label_c1009: (void)0; /*placeholder for label*/ 
56243     { 
56244       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56245       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56246       nextPC = 6 + MATCH_p; 
56247       
56248 #line 1429 "frontend/machine/pentium/decoder.m"
56249       
56250 
56251             stmts = instantiate(pc,  "SBBrmod", DIS_REG32, DIS_EADDR32);
56252 
56253       
56254 
56255       
56256       
56257       
56258     } 
56259     goto MATCH_finished_c; 
56260     
56261   MATCH_label_c1010: (void)0; /*placeholder for label*/ 
56262     { 
56263       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56264       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56265       nextPC = 2 + MATCH_p; 
56266       
56267 #line 1531 "frontend/machine/pentium/decoder.m"
56268       
56269 
56270             stmts = instantiate(pc,  "SUBmrb", DIS_EADDR8, DIS_R8);
56271 
56272       
56273 
56274       
56275       
56276       
56277     } 
56278     goto MATCH_finished_c; 
56279     
56280   MATCH_label_c1011: (void)0; /*placeholder for label*/ 
56281     { 
56282       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56283       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56284       nextPC = 3 + MATCH_p; 
56285       
56286 #line 1531 "frontend/machine/pentium/decoder.m"
56287       
56288 
56289             stmts = instantiate(pc,  "SUBmrb", DIS_EADDR8, DIS_R8);
56290 
56291       
56292 
56293       
56294       
56295       
56296     } 
56297     goto MATCH_finished_c; 
56298     
56299   MATCH_label_c1012: (void)0; /*placeholder for label*/ 
56300     { 
56301       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56302       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56303       nextPC = 7 + MATCH_p; 
56304       
56305 #line 1531 "frontend/machine/pentium/decoder.m"
56306       
56307 
56308             stmts = instantiate(pc,  "SUBmrb", DIS_EADDR8, DIS_R8);
56309 
56310       
56311 
56312       
56313       
56314       
56315     } 
56316     goto MATCH_finished_c; 
56317     
56318   MATCH_label_c1013: (void)0; /*placeholder for label*/ 
56319     { 
56320       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56321       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56322       nextPC = 6 + MATCH_p; 
56323       
56324 #line 1531 "frontend/machine/pentium/decoder.m"
56325       
56326 
56327             stmts = instantiate(pc,  "SUBmrb", DIS_EADDR8, DIS_R8);
56328 
56329       
56330 
56331       
56332       
56333       
56334     } 
56335     goto MATCH_finished_c; 
56336     
56337   MATCH_label_c1014: (void)0; /*placeholder for label*/ 
56338     { 
56339       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56340       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56341       nextPC = 2 + MATCH_p; 
56342       
56343 #line 1489 "frontend/machine/pentium/decoder.m"
56344       
56345 
56346             stmts = instantiate(pc,  "SUBmrod", DIS_EADDR32, DIS_REG32);
56347 
56348       
56349 
56350       
56351       
56352       
56353     } 
56354     goto MATCH_finished_c; 
56355     
56356   MATCH_label_c1015: (void)0; /*placeholder for label*/ 
56357     { 
56358       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56359       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56360       nextPC = 3 + MATCH_p; 
56361       
56362 #line 1489 "frontend/machine/pentium/decoder.m"
56363       
56364 
56365             stmts = instantiate(pc,  "SUBmrod", DIS_EADDR32, DIS_REG32);
56366 
56367       
56368 
56369       
56370       
56371       
56372     } 
56373     goto MATCH_finished_c; 
56374     
56375   MATCH_label_c1016: (void)0; /*placeholder for label*/ 
56376     { 
56377       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56378       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56379       nextPC = 7 + MATCH_p; 
56380       
56381 #line 1489 "frontend/machine/pentium/decoder.m"
56382       
56383 
56384             stmts = instantiate(pc,  "SUBmrod", DIS_EADDR32, DIS_REG32);
56385 
56386       
56387 
56388       
56389       
56390       
56391     } 
56392     goto MATCH_finished_c; 
56393     
56394   MATCH_label_c1017: (void)0; /*placeholder for label*/ 
56395     { 
56396       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56397       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56398       nextPC = 6 + MATCH_p; 
56399       
56400 #line 1489 "frontend/machine/pentium/decoder.m"
56401       
56402 
56403             stmts = instantiate(pc,  "SUBmrod", DIS_EADDR32, DIS_REG32);
56404 
56405       
56406 
56407       
56408       
56409       
56410     } 
56411     goto MATCH_finished_c; 
56412     
56413   MATCH_label_c1018: (void)0; /*placeholder for label*/ 
56414     { 
56415       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56416       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56417       nextPC = 2 + MATCH_p; 
56418       
56419 #line 1459 "frontend/machine/pentium/decoder.m"
56420       
56421 
56422             stmts = instantiate(pc,  "SUBrmb", DIS_R8, DIS_EADDR8);
56423 
56424       
56425 
56426       
56427       
56428       
56429     } 
56430     goto MATCH_finished_c; 
56431     
56432   MATCH_label_c1019: (void)0; /*placeholder for label*/ 
56433     { 
56434       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56435       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56436       nextPC = 3 + MATCH_p; 
56437       
56438 #line 1459 "frontend/machine/pentium/decoder.m"
56439       
56440 
56441             stmts = instantiate(pc,  "SUBrmb", DIS_R8, DIS_EADDR8);
56442 
56443       
56444 
56445       
56446       
56447       
56448     } 
56449     goto MATCH_finished_c; 
56450     
56451   MATCH_label_c1020: (void)0; /*placeholder for label*/ 
56452     { 
56453       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56454       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56455       nextPC = 7 + MATCH_p; 
56456       
56457 #line 1459 "frontend/machine/pentium/decoder.m"
56458       
56459 
56460             stmts = instantiate(pc,  "SUBrmb", DIS_R8, DIS_EADDR8);
56461 
56462       
56463 
56464       
56465       
56466       
56467     } 
56468     goto MATCH_finished_c; 
56469     
56470   MATCH_label_c1021: (void)0; /*placeholder for label*/ 
56471     { 
56472       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56473       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56474       nextPC = 6 + MATCH_p; 
56475       
56476 #line 1459 "frontend/machine/pentium/decoder.m"
56477       
56478 
56479             stmts = instantiate(pc,  "SUBrmb", DIS_R8, DIS_EADDR8);
56480 
56481       
56482 
56483       
56484       
56485       
56486     } 
56487     goto MATCH_finished_c; 
56488     
56489   MATCH_label_c1022: (void)0; /*placeholder for label*/ 
56490     { 
56491       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56492       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56493       nextPC = 2 + MATCH_p; 
56494       
56495 #line 1417 "frontend/machine/pentium/decoder.m"
56496       
56497 
56498             stmts = instantiate(pc,  "SUBrmod", DIS_REG32, DIS_EADDR32);
56499 
56500       
56501 
56502       
56503       
56504       
56505     } 
56506     goto MATCH_finished_c; 
56507     
56508   MATCH_label_c1023: (void)0; /*placeholder for label*/ 
56509     { 
56510       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56511       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56512       nextPC = 3 + MATCH_p; 
56513       
56514 #line 1417 "frontend/machine/pentium/decoder.m"
56515       
56516 
56517             stmts = instantiate(pc,  "SUBrmod", DIS_REG32, DIS_EADDR32);
56518 
56519       
56520 
56521       
56522       
56523       
56524     } 
56525     goto MATCH_finished_c; 
56526     
56527   MATCH_label_c1024: (void)0; /*placeholder for label*/ 
56528     { 
56529       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56530       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56531       nextPC = 7 + MATCH_p; 
56532       
56533 #line 1417 "frontend/machine/pentium/decoder.m"
56534       
56535 
56536             stmts = instantiate(pc,  "SUBrmod", DIS_REG32, DIS_EADDR32);
56537 
56538       
56539 
56540       
56541       
56542       
56543     } 
56544     goto MATCH_finished_c; 
56545     
56546   MATCH_label_c1025: (void)0; /*placeholder for label*/ 
56547     { 
56548       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56549       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56550       nextPC = 6 + MATCH_p; 
56551       
56552 #line 1417 "frontend/machine/pentium/decoder.m"
56553       
56554 
56555             stmts = instantiate(pc,  "SUBrmod", DIS_REG32, DIS_EADDR32);
56556 
56557       
56558 
56559       
56560       
56561       
56562     } 
56563     goto MATCH_finished_c; 
56564     
56565   MATCH_label_c1026: (void)0; /*placeholder for label*/ 
56566     { 
56567       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56568       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56569       nextPC = 2 + MATCH_p; 
56570       
56571 #line 1525 "frontend/machine/pentium/decoder.m"
56572       
56573 
56574             stmts = instantiate(pc,  "CMPmrb", DIS_EADDR8, DIS_R8);
56575 
56576       
56577 
56578       
56579       
56580       
56581     } 
56582     goto MATCH_finished_c; 
56583     
56584   MATCH_label_c1027: (void)0; /*placeholder for label*/ 
56585     { 
56586       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56587       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56588       nextPC = 3 + MATCH_p; 
56589       
56590 #line 1525 "frontend/machine/pentium/decoder.m"
56591       
56592 
56593             stmts = instantiate(pc,  "CMPmrb", DIS_EADDR8, DIS_R8);
56594 
56595       
56596 
56597       
56598       
56599       
56600     } 
56601     goto MATCH_finished_c; 
56602     
56603   MATCH_label_c1028: (void)0; /*placeholder for label*/ 
56604     { 
56605       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56606       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56607       nextPC = 7 + MATCH_p; 
56608       
56609 #line 1525 "frontend/machine/pentium/decoder.m"
56610       
56611 
56612             stmts = instantiate(pc,  "CMPmrb", DIS_EADDR8, DIS_R8);
56613 
56614       
56615 
56616       
56617       
56618       
56619     } 
56620     goto MATCH_finished_c; 
56621     
56622   MATCH_label_c1029: (void)0; /*placeholder for label*/ 
56623     { 
56624       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56625       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56626       nextPC = 6 + MATCH_p; 
56627       
56628 #line 1525 "frontend/machine/pentium/decoder.m"
56629       
56630 
56631             stmts = instantiate(pc,  "CMPmrb", DIS_EADDR8, DIS_R8);
56632 
56633       
56634 
56635       
56636       
56637       
56638     } 
56639     goto MATCH_finished_c; 
56640     
56641   MATCH_label_c1030: (void)0; /*placeholder for label*/ 
56642     { 
56643       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56644       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56645       nextPC = 2 + MATCH_p; 
56646       
56647 #line 1477 "frontend/machine/pentium/decoder.m"
56648       
56649 
56650             stmts = instantiate(pc,  "CMPmrod", DIS_EADDR32, DIS_REG32);
56651 
56652       
56653 
56654       
56655       
56656       
56657     } 
56658     goto MATCH_finished_c; 
56659     
56660   MATCH_label_c1031: (void)0; /*placeholder for label*/ 
56661     { 
56662       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56663       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56664       nextPC = 3 + MATCH_p; 
56665       
56666 #line 1477 "frontend/machine/pentium/decoder.m"
56667       
56668 
56669             stmts = instantiate(pc,  "CMPmrod", DIS_EADDR32, DIS_REG32);
56670 
56671       
56672 
56673       
56674       
56675       
56676     } 
56677     goto MATCH_finished_c; 
56678     
56679   MATCH_label_c1032: (void)0; /*placeholder for label*/ 
56680     { 
56681       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56682       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56683       nextPC = 7 + MATCH_p; 
56684       
56685 #line 1477 "frontend/machine/pentium/decoder.m"
56686       
56687 
56688             stmts = instantiate(pc,  "CMPmrod", DIS_EADDR32, DIS_REG32);
56689 
56690       
56691 
56692       
56693       
56694       
56695     } 
56696     goto MATCH_finished_c; 
56697     
56698   MATCH_label_c1033: (void)0; /*placeholder for label*/ 
56699     { 
56700       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56701       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56702       nextPC = 6 + MATCH_p; 
56703       
56704 #line 1477 "frontend/machine/pentium/decoder.m"
56705       
56706 
56707             stmts = instantiate(pc,  "CMPmrod", DIS_EADDR32, DIS_REG32);
56708 
56709       
56710 
56711       
56712       
56713       
56714     } 
56715     goto MATCH_finished_c; 
56716     
56717   MATCH_label_c1034: (void)0; /*placeholder for label*/ 
56718     { 
56719       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56720       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56721       nextPC = 2 + MATCH_p; 
56722       
56723 #line 1453 "frontend/machine/pentium/decoder.m"
56724       
56725 
56726             stmts = instantiate(pc,  "CMPrmb", DIS_R8, DIS_EADDR8);
56727 
56728       
56729 
56730       
56731       
56732       
56733     } 
56734     goto MATCH_finished_c; 
56735     
56736   MATCH_label_c1035: (void)0; /*placeholder for label*/ 
56737     { 
56738       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56739       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56740       nextPC = 3 + MATCH_p; 
56741       
56742 #line 1453 "frontend/machine/pentium/decoder.m"
56743       
56744 
56745             stmts = instantiate(pc,  "CMPrmb", DIS_R8, DIS_EADDR8);
56746 
56747       
56748 
56749       
56750       
56751       
56752     } 
56753     goto MATCH_finished_c; 
56754     
56755   MATCH_label_c1036: (void)0; /*placeholder for label*/ 
56756     { 
56757       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56758       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56759       nextPC = 7 + MATCH_p; 
56760       
56761 #line 1453 "frontend/machine/pentium/decoder.m"
56762       
56763 
56764             stmts = instantiate(pc,  "CMPrmb", DIS_R8, DIS_EADDR8);
56765 
56766       
56767 
56768       
56769       
56770       
56771     } 
56772     goto MATCH_finished_c; 
56773     
56774   MATCH_label_c1037: (void)0; /*placeholder for label*/ 
56775     { 
56776       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56777       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56778       nextPC = 6 + MATCH_p; 
56779       
56780 #line 1453 "frontend/machine/pentium/decoder.m"
56781       
56782 
56783             stmts = instantiate(pc,  "CMPrmb", DIS_R8, DIS_EADDR8);
56784 
56785       
56786 
56787       
56788       
56789       
56790     } 
56791     goto MATCH_finished_c; 
56792     
56793   MATCH_label_c1038: (void)0; /*placeholder for label*/ 
56794     { 
56795       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56796       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56797       nextPC = 2 + MATCH_p; 
56798       
56799 #line 1405 "frontend/machine/pentium/decoder.m"
56800       
56801 
56802             stmts = instantiate(pc,  "CMPrmod", DIS_REG32, DIS_EADDR32);
56803 
56804       
56805 
56806       
56807       
56808       
56809     } 
56810     goto MATCH_finished_c; 
56811     
56812   MATCH_label_c1039: (void)0; /*placeholder for label*/ 
56813     { 
56814       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56815       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56816       nextPC = 3 + MATCH_p; 
56817       
56818 #line 1405 "frontend/machine/pentium/decoder.m"
56819       
56820 
56821             stmts = instantiate(pc,  "CMPrmod", DIS_REG32, DIS_EADDR32);
56822 
56823       
56824 
56825       
56826       
56827       
56828     } 
56829     goto MATCH_finished_c; 
56830     
56831   MATCH_label_c1040: (void)0; /*placeholder for label*/ 
56832     { 
56833       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56834       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56835       nextPC = 7 + MATCH_p; 
56836       
56837 #line 1405 "frontend/machine/pentium/decoder.m"
56838       
56839 
56840             stmts = instantiate(pc,  "CMPrmod", DIS_REG32, DIS_EADDR32);
56841 
56842       
56843 
56844       
56845       
56846       
56847     } 
56848     goto MATCH_finished_c; 
56849     
56850   MATCH_label_c1041: (void)0; /*placeholder for label*/ 
56851     { 
56852       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56853       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56854       nextPC = 6 + MATCH_p; 
56855       
56856 #line 1405 "frontend/machine/pentium/decoder.m"
56857       
56858 
56859             stmts = instantiate(pc,  "CMPrmod", DIS_REG32, DIS_EADDR32);
56860 
56861       
56862 
56863       
56864       
56865       
56866     } 
56867     goto MATCH_finished_c; 
56868     
56869   MATCH_label_c1042: (void)0; /*placeholder for label*/ 
56870     { 
56871       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56872       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
56873       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56874       nextPC = 6 + MATCH_p; 
56875       
56876 #line 1154 "frontend/machine/pentium/decoder.m"
56877       
56878 
56879             stmts = instantiate(pc,  "IMUL.Ivd", DIS_REG32, DIS_EADDR32, DIS_I32);
56880 
56881       
56882 
56883       
56884       
56885       
56886     } 
56887     goto MATCH_finished_c; 
56888     
56889   MATCH_label_c1043: (void)0; /*placeholder for label*/ 
56890     { 
56891       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56892       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
56893       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56894       nextPC = 7 + MATCH_p; 
56895       
56896 #line 1154 "frontend/machine/pentium/decoder.m"
56897       
56898 
56899             stmts = instantiate(pc,  "IMUL.Ivd", DIS_REG32, DIS_EADDR32, DIS_I32);
56900 
56901       
56902 
56903       
56904       
56905       
56906     } 
56907     goto MATCH_finished_c; 
56908     
56909   MATCH_label_c1044: (void)0; /*placeholder for label*/ 
56910     { 
56911       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56912       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
56913       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56914       nextPC = 11 + MATCH_p; 
56915       
56916 #line 1154 "frontend/machine/pentium/decoder.m"
56917       
56918 
56919             stmts = instantiate(pc,  "IMUL.Ivd", DIS_REG32, DIS_EADDR32, DIS_I32);
56920 
56921       
56922 
56923       
56924       
56925       
56926     } 
56927     goto MATCH_finished_c; 
56928     
56929   MATCH_label_c1045: (void)0; /*placeholder for label*/ 
56930     { 
56931       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56932       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
56933       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56934       nextPC = 10 + MATCH_p; 
56935       
56936 #line 1154 "frontend/machine/pentium/decoder.m"
56937       
56938 
56939             stmts = instantiate(pc,  "IMUL.Ivd", DIS_REG32, DIS_EADDR32, DIS_I32);
56940 
56941       
56942 
56943       
56944       
56945       
56946     } 
56947     goto MATCH_finished_c; 
56948     
56949   MATCH_label_c1046: (void)0; /*placeholder for label*/ 
56950     { 
56951       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56952       int /* [~128..127] */ i8 = 
56953         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
56954       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56955       nextPC = 3 + MATCH_p; 
56956       
56957 #line 1160 "frontend/machine/pentium/decoder.m"
56958       
56959 
56960             stmts = instantiate(pc,  "IMUL.Ibod", DIS_REG32, DIS_EADDR32, DIS_I8);
56961 
56962       
56963 
56964       
56965       
56966       
56967     } 
56968     goto MATCH_finished_c; 
56969     
56970   MATCH_label_c1047: (void)0; /*placeholder for label*/ 
56971     { 
56972       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56973       int /* [~128..127] */ i8 = 
56974         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
56975       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56976       nextPC = 4 + MATCH_p; 
56977       
56978 #line 1160 "frontend/machine/pentium/decoder.m"
56979       
56980 
56981             stmts = instantiate(pc,  "IMUL.Ibod", DIS_REG32, DIS_EADDR32, DIS_I8);
56982 
56983       
56984 
56985       
56986       
56987       
56988     } 
56989     goto MATCH_finished_c; 
56990     
56991   MATCH_label_c1048: (void)0; /*placeholder for label*/ 
56992     { 
56993       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56994       int /* [~128..127] */ i8 = 
56995         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
56996       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
56997       nextPC = 8 + MATCH_p; 
56998       
56999 #line 1160 "frontend/machine/pentium/decoder.m"
57000       
57001 
57002             stmts = instantiate(pc,  "IMUL.Ibod", DIS_REG32, DIS_EADDR32, DIS_I8);
57003 
57004       
57005 
57006       
57007       
57008       
57009     } 
57010     goto MATCH_finished_c; 
57011     
57012   MATCH_label_c1049: (void)0; /*placeholder for label*/ 
57013     { 
57014       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57015       int /* [~128..127] */ i8 = 
57016         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
57017       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57018       nextPC = 7 + MATCH_p; 
57019       
57020 #line 1160 "frontend/machine/pentium/decoder.m"
57021       
57022 
57023             stmts = instantiate(pc,  "IMUL.Ibod", DIS_REG32, DIS_EADDR32, DIS_I8);
57024 
57025       
57026 
57027       
57028       
57029       
57030     } 
57031     goto MATCH_finished_c; 
57032     
57033   MATCH_label_c1050: (void)0; /*placeholder for label*/ 
57034     { 
57035       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57036       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57037       nextPC = 2 + MATCH_p; 
57038       
57039 #line 1037 "frontend/machine/pentium/decoder.m"
57040       
57041 
57042             stmts = instantiate(pc,  "MOVmrb", DIS_EADDR8, DIS_REG8);
57043 
57044       
57045 
57046       
57047       
57048       
57049     } 
57050     goto MATCH_finished_c; 
57051     
57052   MATCH_label_c1051: (void)0; /*placeholder for label*/ 
57053     { 
57054       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57055       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57056       nextPC = 3 + MATCH_p; 
57057       
57058 #line 1037 "frontend/machine/pentium/decoder.m"
57059       
57060 
57061             stmts = instantiate(pc,  "MOVmrb", DIS_EADDR8, DIS_REG8);
57062 
57063       
57064 
57065       
57066       
57067       
57068     } 
57069     goto MATCH_finished_c; 
57070     
57071   MATCH_label_c1052: (void)0; /*placeholder for label*/ 
57072     { 
57073       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57074       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57075       nextPC = 7 + MATCH_p; 
57076       
57077 #line 1037 "frontend/machine/pentium/decoder.m"
57078       
57079 
57080             stmts = instantiate(pc,  "MOVmrb", DIS_EADDR8, DIS_REG8);
57081 
57082       
57083 
57084       
57085       
57086       
57087     } 
57088     goto MATCH_finished_c; 
57089     
57090   MATCH_label_c1053: (void)0; /*placeholder for label*/ 
57091     { 
57092       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57093       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57094       nextPC = 6 + MATCH_p; 
57095       
57096 #line 1037 "frontend/machine/pentium/decoder.m"
57097       
57098 
57099             stmts = instantiate(pc,  "MOVmrb", DIS_EADDR8, DIS_REG8);
57100 
57101       
57102 
57103       
57104       
57105       
57106     } 
57107     goto MATCH_finished_c; 
57108     
57109   MATCH_label_c1054: (void)0; /*placeholder for label*/ 
57110     { 
57111       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57112       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57113       nextPC = 2 + MATCH_p; 
57114       
57115 #line 1031 "frontend/machine/pentium/decoder.m"
57116       
57117 
57118             stmts = instantiate(pc,  "MOVmrod", DIS_EADDR32, DIS_REG32);
57119 
57120       
57121 
57122       
57123       
57124       
57125     } 
57126     goto MATCH_finished_c; 
57127     
57128   MATCH_label_c1055: (void)0; /*placeholder for label*/ 
57129     { 
57130       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57131       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57132       nextPC = 3 + MATCH_p; 
57133       
57134 #line 1031 "frontend/machine/pentium/decoder.m"
57135       
57136 
57137             stmts = instantiate(pc,  "MOVmrod", DIS_EADDR32, DIS_REG32);
57138 
57139       
57140 
57141       
57142       
57143       
57144     } 
57145     goto MATCH_finished_c; 
57146     
57147   MATCH_label_c1056: (void)0; /*placeholder for label*/ 
57148     { 
57149       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57150       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57151       nextPC = 7 + MATCH_p; 
57152       
57153 #line 1031 "frontend/machine/pentium/decoder.m"
57154       
57155 
57156             stmts = instantiate(pc,  "MOVmrod", DIS_EADDR32, DIS_REG32);
57157 
57158       
57159 
57160       
57161       
57162       
57163     } 
57164     goto MATCH_finished_c; 
57165     
57166   MATCH_label_c1057: (void)0; /*placeholder for label*/ 
57167     { 
57168       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57169       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57170       nextPC = 6 + MATCH_p; 
57171       
57172 #line 1031 "frontend/machine/pentium/decoder.m"
57173       
57174 
57175             stmts = instantiate(pc,  "MOVmrod", DIS_EADDR32, DIS_REG32);
57176 
57177       
57178 
57179       
57180       
57181       
57182     } 
57183     goto MATCH_finished_c; 
57184     
57185   MATCH_label_c1058: (void)0; /*placeholder for label*/ 
57186     { 
57187       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57188       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57189       nextPC = 2 + MATCH_p; 
57190       
57191 #line 1028 "frontend/machine/pentium/decoder.m"
57192       
57193 
57194             stmts = instantiate(pc,  "MOVrmb", DIS_REG8, DIS_EADDR8);
57195 
57196       
57197 
57198       
57199       
57200       
57201     } 
57202     goto MATCH_finished_c; 
57203     
57204   MATCH_label_c1059: (void)0; /*placeholder for label*/ 
57205     { 
57206       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57207       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57208       nextPC = 3 + MATCH_p; 
57209       
57210 #line 1028 "frontend/machine/pentium/decoder.m"
57211       
57212 
57213             stmts = instantiate(pc,  "MOVrmb", DIS_REG8, DIS_EADDR8);
57214 
57215       
57216 
57217       
57218       
57219       
57220     } 
57221     goto MATCH_finished_c; 
57222     
57223   MATCH_label_c1060: (void)0; /*placeholder for label*/ 
57224     { 
57225       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57226       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57227       nextPC = 7 + MATCH_p; 
57228       
57229 #line 1028 "frontend/machine/pentium/decoder.m"
57230       
57231 
57232             stmts = instantiate(pc,  "MOVrmb", DIS_REG8, DIS_EADDR8);
57233 
57234       
57235 
57236       
57237       
57238       
57239     } 
57240     goto MATCH_finished_c; 
57241     
57242   MATCH_label_c1061: (void)0; /*placeholder for label*/ 
57243     { 
57244       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57245       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57246       nextPC = 6 + MATCH_p; 
57247       
57248 #line 1028 "frontend/machine/pentium/decoder.m"
57249       
57250 
57251             stmts = instantiate(pc,  "MOVrmb", DIS_REG8, DIS_EADDR8);
57252 
57253       
57254 
57255       
57256       
57257       
57258     } 
57259     goto MATCH_finished_c; 
57260     
57261   MATCH_label_c1062: (void)0; /*placeholder for label*/ 
57262     { 
57263       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57264       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57265       nextPC = 2 + MATCH_p; 
57266       
57267 #line 1022 "frontend/machine/pentium/decoder.m"
57268       
57269 
57270             stmts = instantiate(pc,  "MOVrmod", DIS_REG32, DIS_EADDR32);
57271 
57272       
57273 
57274       
57275       
57276       
57277     } 
57278     goto MATCH_finished_c; 
57279     
57280   MATCH_label_c1063: (void)0; /*placeholder for label*/ 
57281     { 
57282       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57283       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57284       nextPC = 3 + MATCH_p; 
57285       
57286 #line 1022 "frontend/machine/pentium/decoder.m"
57287       
57288 
57289             stmts = instantiate(pc,  "MOVrmod", DIS_REG32, DIS_EADDR32);
57290 
57291       
57292 
57293       
57294       
57295       
57296     } 
57297     goto MATCH_finished_c; 
57298     
57299   MATCH_label_c1064: (void)0; /*placeholder for label*/ 
57300     { 
57301       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57302       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57303       nextPC = 7 + MATCH_p; 
57304       
57305 #line 1022 "frontend/machine/pentium/decoder.m"
57306       
57307 
57308             stmts = instantiate(pc,  "MOVrmod", DIS_REG32, DIS_EADDR32);
57309 
57310       
57311 
57312       
57313       
57314       
57315     } 
57316     goto MATCH_finished_c; 
57317     
57318   MATCH_label_c1065: (void)0; /*placeholder for label*/ 
57319     { 
57320       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57321       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57322       nextPC = 6 + MATCH_p; 
57323       
57324 #line 1022 "frontend/machine/pentium/decoder.m"
57325       
57326 
57327             stmts = instantiate(pc,  "MOVrmod", DIS_REG32, DIS_EADDR32);
57328 
57329       
57330 
57331       
57332       
57333       
57334     } 
57335     goto MATCH_finished_c; 
57336     
57337   MATCH_label_c1066: (void)0; /*placeholder for label*/ 
57338     { 
57339       unsigned Mem = 1 + addressToPC(MATCH_p);
57340       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57341       nextPC = 3 + MATCH_p; 
57342       
57343 #line 1073 "frontend/machine/pentium/decoder.m"
57344       
57345 
57346             stmts = instantiate(pc,  "LEA.od", DIS_REG32, DIS_MEM);
57347 
57348       
57349 
57350       
57351       
57352       
57353     } 
57354     goto MATCH_finished_c; 
57355     
57356   MATCH_label_c1067: (void)0; /*placeholder for label*/ 
57357     { 
57358       unsigned Mem = 1 + addressToPC(MATCH_p);
57359       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57360       nextPC = 7 + MATCH_p; 
57361       
57362 #line 1073 "frontend/machine/pentium/decoder.m"
57363       
57364 
57365             stmts = instantiate(pc,  "LEA.od", DIS_REG32, DIS_MEM);
57366 
57367       
57368 
57369       
57370       
57371       
57372     } 
57373     goto MATCH_finished_c; 
57374     
57375   MATCH_label_c1068: (void)0; /*placeholder for label*/ 
57376     { 
57377       unsigned Mem = 1 + addressToPC(MATCH_p);
57378       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
57379       nextPC = 6 + MATCH_p; 
57380       
57381 #line 1073 "frontend/machine/pentium/decoder.m"
57382       
57383 
57384             stmts = instantiate(pc,  "LEA.od", DIS_REG32, DIS_MEM);
57385 
57386       
57387 
57388       
57389       
57390       
57391     } 
57392     goto MATCH_finished_c; 
57393     
57394   MATCH_label_c1069: (void)0; /*placeholder for label*/ 
57395     { 
57396       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57397       nextPC = 2 + MATCH_p; 
57398       
57399 #line 877 "frontend/machine/pentium/decoder.m"
57400       
57401 
57402             stmts = instantiate(pc,  "POP.Evod", DIS_EADDR32);
57403 
57404       
57405 
57406       
57407       
57408       
57409     } 
57410     goto MATCH_finished_c; 
57411     
57412   MATCH_label_c1070: (void)0; /*placeholder for label*/ 
57413     { 
57414       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57415       nextPC = 3 + MATCH_p; 
57416       
57417 #line 877 "frontend/machine/pentium/decoder.m"
57418       
57419 
57420             stmts = instantiate(pc,  "POP.Evod", DIS_EADDR32);
57421 
57422       
57423 
57424       
57425       
57426       
57427     } 
57428     goto MATCH_finished_c; 
57429     
57430   MATCH_label_c1071: (void)0; /*placeholder for label*/ 
57431     { 
57432       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57433       nextPC = 7 + MATCH_p; 
57434       
57435 #line 877 "frontend/machine/pentium/decoder.m"
57436       
57437 
57438             stmts = instantiate(pc,  "POP.Evod", DIS_EADDR32);
57439 
57440       
57441 
57442       
57443       
57444       
57445     } 
57446     goto MATCH_finished_c; 
57447     
57448   MATCH_label_c1072: (void)0; /*placeholder for label*/ 
57449     { 
57450       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57451       nextPC = 6 + MATCH_p; 
57452       
57453 #line 877 "frontend/machine/pentium/decoder.m"
57454       
57455 
57456             stmts = instantiate(pc,  "POP.Evod", DIS_EADDR32);
57457 
57458       
57459 
57460       
57461       
57462       
57463     } 
57464     goto MATCH_finished_c; 
57465     
57466   MATCH_label_c1073: (void)0; /*placeholder for label*/ 
57467     { 
57468       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57469       nextPC = 3 + MATCH_p; 
57470       
57471 #line 1760 "frontend/machine/pentium/decoder.m"
57472       
57473 
57474             stmts = instantiate(pc,  "FADD.R32", DIS_MEM32);
57475 
57476       
57477 
57478       
57479       
57480       
57481     } 
57482     goto MATCH_finished_c; 
57483     
57484   MATCH_label_c1074: (void)0; /*placeholder for label*/ 
57485     { 
57486       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57487       nextPC = 7 + MATCH_p; 
57488       
57489 #line 1760 "frontend/machine/pentium/decoder.m"
57490       
57491 
57492             stmts = instantiate(pc,  "FADD.R32", DIS_MEM32);
57493 
57494       
57495 
57496       
57497       
57498       
57499     } 
57500     goto MATCH_finished_c; 
57501     
57502   MATCH_label_c1075: (void)0; /*placeholder for label*/ 
57503     { 
57504       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57505       nextPC = 6 + MATCH_p; 
57506       
57507 #line 1760 "frontend/machine/pentium/decoder.m"
57508       
57509 
57510             stmts = instantiate(pc,  "FADD.R32", DIS_MEM32);
57511 
57512       
57513 
57514       
57515       
57516       
57517     } 
57518     goto MATCH_finished_c; 
57519     
57520   MATCH_label_c1076: (void)0; /*placeholder for label*/ 
57521     { 
57522       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57523       nextPC = 3 + MATCH_p; 
57524       
57525 #line 1954 "frontend/machine/pentium/decoder.m"
57526       
57527 
57528             stmts = instantiate(pc,  "FMUL.R32", DIS_MEM32);
57529 
57530       
57531 
57532       
57533       
57534       
57535     } 
57536     goto MATCH_finished_c; 
57537     
57538   MATCH_label_c1077: (void)0; /*placeholder for label*/ 
57539     { 
57540       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57541       nextPC = 7 + MATCH_p; 
57542       
57543 #line 1954 "frontend/machine/pentium/decoder.m"
57544       
57545 
57546             stmts = instantiate(pc,  "FMUL.R32", DIS_MEM32);
57547 
57548       
57549 
57550       
57551       
57552       
57553     } 
57554     goto MATCH_finished_c; 
57555     
57556   MATCH_label_c1078: (void)0; /*placeholder for label*/ 
57557     { 
57558       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57559       nextPC = 6 + MATCH_p; 
57560       
57561 #line 1954 "frontend/machine/pentium/decoder.m"
57562       
57563 
57564             stmts = instantiate(pc,  "FMUL.R32", DIS_MEM32);
57565 
57566       
57567 
57568       
57569       
57570       
57571     } 
57572     goto MATCH_finished_c; 
57573     
57574   MATCH_label_c1079: (void)0; /*placeholder for label*/ 
57575     { 
57576       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57577       nextPC = 3 + MATCH_p; 
57578       
57579 #line 1793 "frontend/machine/pentium/decoder.m"
57580       
57581 
57582             stmts = instantiate(pc,  "FCOM.R32", DIS_MEM32);
57583 
57584       
57585 
57586       
57587       
57588       
57589     } 
57590     goto MATCH_finished_c; 
57591     
57592   MATCH_label_c1080: (void)0; /*placeholder for label*/ 
57593     { 
57594       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57595       nextPC = 7 + MATCH_p; 
57596       
57597 #line 1793 "frontend/machine/pentium/decoder.m"
57598       
57599 
57600             stmts = instantiate(pc,  "FCOM.R32", DIS_MEM32);
57601 
57602       
57603 
57604       
57605       
57606       
57607     } 
57608     goto MATCH_finished_c; 
57609     
57610   MATCH_label_c1081: (void)0; /*placeholder for label*/ 
57611     { 
57612       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57613       nextPC = 6 + MATCH_p; 
57614       
57615 #line 1793 "frontend/machine/pentium/decoder.m"
57616       
57617 
57618             stmts = instantiate(pc,  "FCOM.R32", DIS_MEM32);
57619 
57620       
57621 
57622       
57623       
57624       
57625     } 
57626     goto MATCH_finished_c; 
57627     
57628   MATCH_label_c1082: (void)0; /*placeholder for label*/ 
57629     { 
57630       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57631       nextPC = 3 + MATCH_p; 
57632       
57633 #line 1805 "frontend/machine/pentium/decoder.m"
57634       
57635 
57636             stmts = instantiate(pc,  "FCOMP.R32", DIS_MEM32);
57637 
57638       
57639 
57640       
57641       
57642       
57643     } 
57644     goto MATCH_finished_c; 
57645     
57646   MATCH_label_c1083: (void)0; /*placeholder for label*/ 
57647     { 
57648       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57649       nextPC = 7 + MATCH_p; 
57650       
57651 #line 1805 "frontend/machine/pentium/decoder.m"
57652       
57653 
57654             stmts = instantiate(pc,  "FCOMP.R32", DIS_MEM32);
57655 
57656       
57657 
57658       
57659       
57660       
57661     } 
57662     goto MATCH_finished_c; 
57663     
57664   MATCH_label_c1084: (void)0; /*placeholder for label*/ 
57665     { 
57666       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57667       nextPC = 6 + MATCH_p; 
57668       
57669 #line 1805 "frontend/machine/pentium/decoder.m"
57670       
57671 
57672             stmts = instantiate(pc,  "FCOMP.R32", DIS_MEM32);
57673 
57674       
57675 
57676       
57677       
57678       
57679     } 
57680     goto MATCH_finished_c; 
57681     
57682   MATCH_label_c1085: (void)0; /*placeholder for label*/ 
57683     { 
57684       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57685       nextPC = 3 + MATCH_p; 
57686       
57687 #line 2044 "frontend/machine/pentium/decoder.m"
57688       
57689 
57690             stmts = instantiate(pc,  "FSUB.R32", DIS_MEM32);
57691 
57692       
57693 
57694       
57695       
57696       
57697     } 
57698     goto MATCH_finished_c; 
57699     
57700   MATCH_label_c1086: (void)0; /*placeholder for label*/ 
57701     { 
57702       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57703       nextPC = 7 + MATCH_p; 
57704       
57705 #line 2044 "frontend/machine/pentium/decoder.m"
57706       
57707 
57708             stmts = instantiate(pc,  "FSUB.R32", DIS_MEM32);
57709 
57710       
57711 
57712       
57713       
57714       
57715     } 
57716     goto MATCH_finished_c; 
57717     
57718   MATCH_label_c1087: (void)0; /*placeholder for label*/ 
57719     { 
57720       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57721       nextPC = 6 + MATCH_p; 
57722       
57723 #line 2044 "frontend/machine/pentium/decoder.m"
57724       
57725 
57726             stmts = instantiate(pc,  "FSUB.R32", DIS_MEM32);
57727 
57728       
57729 
57730       
57731       
57732       
57733     } 
57734     goto MATCH_finished_c; 
57735     
57736   MATCH_label_c1088: (void)0; /*placeholder for label*/ 
57737     { 
57738       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57739       nextPC = 3 + MATCH_p; 
57740       
57741 #line 2065 "frontend/machine/pentium/decoder.m"
57742       
57743 
57744             stmts = instantiate(pc,  "FSUBR.R32", DIS_MEM32);
57745 
57746       
57747 
57748       
57749       
57750       
57751     } 
57752     goto MATCH_finished_c; 
57753     
57754   MATCH_label_c1089: (void)0; /*placeholder for label*/ 
57755     { 
57756       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57757       nextPC = 7 + MATCH_p; 
57758       
57759 #line 2065 "frontend/machine/pentium/decoder.m"
57760       
57761 
57762             stmts = instantiate(pc,  "FSUBR.R32", DIS_MEM32);
57763 
57764       
57765 
57766       
57767       
57768       
57769     } 
57770     goto MATCH_finished_c; 
57771     
57772   MATCH_label_c1090: (void)0; /*placeholder for label*/ 
57773     { 
57774       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57775       nextPC = 6 + MATCH_p; 
57776       
57777 #line 2065 "frontend/machine/pentium/decoder.m"
57778       
57779 
57780             stmts = instantiate(pc,  "FSUBR.R32", DIS_MEM32);
57781 
57782       
57783 
57784       
57785       
57786       
57787     } 
57788     goto MATCH_finished_c; 
57789     
57790   MATCH_label_c1091: (void)0; /*placeholder for label*/ 
57791     { 
57792       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57793       nextPC = 3 + MATCH_p; 
57794       
57795 #line 1838 "frontend/machine/pentium/decoder.m"
57796       
57797 
57798             stmts = instantiate(pc,  "FDIV.R32", DIS_MEM32);
57799 
57800       
57801 
57802       
57803       
57804       
57805     } 
57806     goto MATCH_finished_c; 
57807     
57808   MATCH_label_c1092: (void)0; /*placeholder for label*/ 
57809     { 
57810       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57811       nextPC = 7 + MATCH_p; 
57812       
57813 #line 1838 "frontend/machine/pentium/decoder.m"
57814       
57815 
57816             stmts = instantiate(pc,  "FDIV.R32", DIS_MEM32);
57817 
57818       
57819 
57820       
57821       
57822       
57823     } 
57824     goto MATCH_finished_c; 
57825     
57826   MATCH_label_c1093: (void)0; /*placeholder for label*/ 
57827     { 
57828       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57829       nextPC = 6 + MATCH_p; 
57830       
57831 #line 1838 "frontend/machine/pentium/decoder.m"
57832       
57833 
57834             stmts = instantiate(pc,  "FDIV.R32", DIS_MEM32);
57835 
57836       
57837 
57838       
57839       
57840       
57841     } 
57842     goto MATCH_finished_c; 
57843     
57844   MATCH_label_c1094: (void)0; /*placeholder for label*/ 
57845     { 
57846       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57847       nextPC = 3 + MATCH_p; 
57848       
57849 #line 1859 "frontend/machine/pentium/decoder.m"
57850       
57851 
57852             stmts = instantiate(pc,  "FDIVR.R32", DIS_MEM32);
57853 
57854       
57855 
57856       
57857       
57858       
57859     } 
57860     goto MATCH_finished_c; 
57861     
57862   MATCH_label_c1095: (void)0; /*placeholder for label*/ 
57863     { 
57864       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57865       nextPC = 7 + MATCH_p; 
57866       
57867 #line 1859 "frontend/machine/pentium/decoder.m"
57868       
57869 
57870             stmts = instantiate(pc,  "FDIVR.R32", DIS_MEM32);
57871 
57872       
57873 
57874       
57875       
57876       
57877     } 
57878     goto MATCH_finished_c; 
57879     
57880   MATCH_label_c1096: (void)0; /*placeholder for label*/ 
57881     { 
57882       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57883       nextPC = 6 + MATCH_p; 
57884       
57885 #line 1859 "frontend/machine/pentium/decoder.m"
57886       
57887 
57888             stmts = instantiate(pc,  "FDIVR.R32", DIS_MEM32);
57889 
57890       
57891 
57892       
57893       
57894       
57895     } 
57896     goto MATCH_finished_c; 
57897     
57898   MATCH_label_c1097: (void)0; /*placeholder for label*/ 
57899     { 
57900       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57901       nextPC = 3 + MATCH_p; 
57902       
57903 #line 1910 "frontend/machine/pentium/decoder.m"
57904       
57905 
57906             stmts = instantiate(pc,  "FLD.lsR32", DIS_MEM32);
57907 
57908       
57909 
57910       
57911       
57912       
57913     } 
57914     goto MATCH_finished_c; 
57915     
57916   MATCH_label_c1098: (void)0; /*placeholder for label*/ 
57917     { 
57918       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57919       nextPC = 7 + MATCH_p; 
57920       
57921 #line 1910 "frontend/machine/pentium/decoder.m"
57922       
57923 
57924             stmts = instantiate(pc,  "FLD.lsR32", DIS_MEM32);
57925 
57926       
57927 
57928       
57929       
57930       
57931     } 
57932     goto MATCH_finished_c; 
57933     
57934   MATCH_label_c1099: (void)0; /*placeholder for label*/ 
57935     { 
57936       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57937       nextPC = 6 + MATCH_p; 
57938       
57939 #line 1910 "frontend/machine/pentium/decoder.m"
57940       
57941 
57942             stmts = instantiate(pc,  "FLD.lsR32", DIS_MEM32);
57943 
57944       
57945 
57946       
57947       
57948       
57949     } 
57950     goto MATCH_finished_c; 
57951     
57952   MATCH_label_c1100: (void)0; /*placeholder for label*/ 
57953     { 
57954       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57955       nextPC = 3 + MATCH_p; 
57956       
57957 #line 2011 "frontend/machine/pentium/decoder.m"
57958       
57959 
57960             stmts = instantiate(pc,  "FST.lsR32", DIS_MEM32);
57961 
57962       
57963 
57964       
57965       
57966       
57967     } 
57968     goto MATCH_finished_c; 
57969     
57970   MATCH_label_c1101: (void)0; /*placeholder for label*/ 
57971     { 
57972       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57973       nextPC = 7 + MATCH_p; 
57974       
57975 #line 2011 "frontend/machine/pentium/decoder.m"
57976       
57977 
57978             stmts = instantiate(pc,  "FST.lsR32", DIS_MEM32);
57979 
57980       
57981 
57982       
57983       
57984       
57985     } 
57986     goto MATCH_finished_c; 
57987     
57988   MATCH_label_c1102: (void)0; /*placeholder for label*/ 
57989     { 
57990       unsigned Mem32 = 1 + addressToPC(MATCH_p);
57991       nextPC = 6 + MATCH_p; 
57992       
57993 #line 2011 "frontend/machine/pentium/decoder.m"
57994       
57995 
57996             stmts = instantiate(pc,  "FST.lsR32", DIS_MEM32);
57997 
57998       
57999 
58000       
58001       
58002       
58003     } 
58004     goto MATCH_finished_c; 
58005     
58006   MATCH_label_c1103: (void)0; /*placeholder for label*/ 
58007     { 
58008       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58009       nextPC = 3 + MATCH_p; 
58010       
58011 #line 2017 "frontend/machine/pentium/decoder.m"
58012       
58013 
58014             stmts = instantiate(pc,  "FSTP.lsR32", DIS_MEM32);
58015 
58016       
58017 
58018       
58019       
58020       
58021     } 
58022     goto MATCH_finished_c; 
58023     
58024   MATCH_label_c1104: (void)0; /*placeholder for label*/ 
58025     { 
58026       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58027       nextPC = 7 + MATCH_p; 
58028       
58029 #line 2017 "frontend/machine/pentium/decoder.m"
58030       
58031 
58032             stmts = instantiate(pc,  "FSTP.lsR32", DIS_MEM32);
58033 
58034       
58035 
58036       
58037       
58038       
58039     } 
58040     goto MATCH_finished_c; 
58041     
58042   MATCH_label_c1105: (void)0; /*placeholder for label*/ 
58043     { 
58044       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58045       nextPC = 6 + MATCH_p; 
58046       
58047 #line 2017 "frontend/machine/pentium/decoder.m"
58048       
58049 
58050             stmts = instantiate(pc,  "FSTP.lsR32", DIS_MEM32);
58051 
58052       
58053 
58054       
58055       
58056       
58057     } 
58058     goto MATCH_finished_c; 
58059     
58060   MATCH_label_c1106: (void)0; /*placeholder for label*/ 
58061     { 
58062       unsigned Mem = 1 + addressToPC(MATCH_p);
58063       nextPC = 3 + MATCH_p; 
58064       
58065 #line 1951 "frontend/machine/pentium/decoder.m"
58066       
58067 
58068             stmts = instantiate(pc,  "FLDENV", DIS_MEM);
58069 
58070       
58071 
58072       
58073       
58074       
58075     } 
58076     goto MATCH_finished_c; 
58077     
58078   MATCH_label_c1107: (void)0; /*placeholder for label*/ 
58079     { 
58080       unsigned Mem = 1 + addressToPC(MATCH_p);
58081       nextPC = 7 + MATCH_p; 
58082       
58083 #line 1951 "frontend/machine/pentium/decoder.m"
58084       
58085 
58086             stmts = instantiate(pc,  "FLDENV", DIS_MEM);
58087 
58088       
58089 
58090       
58091       
58092       
58093     } 
58094     goto MATCH_finished_c; 
58095     
58096   MATCH_label_c1108: (void)0; /*placeholder for label*/ 
58097     { 
58098       unsigned Mem = 1 + addressToPC(MATCH_p);
58099       nextPC = 6 + MATCH_p; 
58100       
58101 #line 1951 "frontend/machine/pentium/decoder.m"
58102       
58103 
58104             stmts = instantiate(pc,  "FLDENV", DIS_MEM);
58105 
58106       
58107 
58108       
58109       
58110       
58111     } 
58112     goto MATCH_finished_c; 
58113     
58114   MATCH_label_c1109: (void)0; /*placeholder for label*/ 
58115     { 
58116       unsigned Mem16 = 1 + addressToPC(MATCH_p);
58117       nextPC = 3 + MATCH_p; 
58118       
58119 #line 1948 "frontend/machine/pentium/decoder.m"
58120       
58121 
58122             stmts = instantiate(pc,  "FLDCW", DIS_MEM16);
58123 
58124       
58125 
58126       
58127       
58128       
58129     } 
58130     goto MATCH_finished_c; 
58131     
58132   MATCH_label_c1110: (void)0; /*placeholder for label*/ 
58133     { 
58134       unsigned Mem16 = 1 + addressToPC(MATCH_p);
58135       nextPC = 7 + MATCH_p; 
58136       
58137 #line 1948 "frontend/machine/pentium/decoder.m"
58138       
58139 
58140             stmts = instantiate(pc,  "FLDCW", DIS_MEM16);
58141 
58142       
58143 
58144       
58145       
58146       
58147     } 
58148     goto MATCH_finished_c; 
58149     
58150   MATCH_label_c1111: (void)0; /*placeholder for label*/ 
58151     { 
58152       unsigned Mem16 = 1 + addressToPC(MATCH_p);
58153       nextPC = 6 + MATCH_p; 
58154       
58155 #line 1948 "frontend/machine/pentium/decoder.m"
58156       
58157 
58158             stmts = instantiate(pc,  "FLDCW", DIS_MEM16);
58159 
58160       
58161 
58162       
58163       
58164       
58165     } 
58166     goto MATCH_finished_c; 
58167     
58168   MATCH_label_c1112: (void)0; /*placeholder for label*/ 
58169     { 
58170       unsigned Mem = 1 + addressToPC(MATCH_p);
58171       nextPC = 3 + MATCH_p; 
58172       
58173 #line 2035 "frontend/machine/pentium/decoder.m"
58174       
58175 
58176             stmts = instantiate(pc,  "FSTENV", DIS_MEM);
58177 
58178       
58179 
58180       
58181       
58182       
58183     } 
58184     goto MATCH_finished_c; 
58185     
58186   MATCH_label_c1113: (void)0; /*placeholder for label*/ 
58187     { 
58188       unsigned Mem = 1 + addressToPC(MATCH_p);
58189       nextPC = 7 + MATCH_p; 
58190       
58191 #line 2035 "frontend/machine/pentium/decoder.m"
58192       
58193 
58194             stmts = instantiate(pc,  "FSTENV", DIS_MEM);
58195 
58196       
58197 
58198       
58199       
58200       
58201     } 
58202     goto MATCH_finished_c; 
58203     
58204   MATCH_label_c1114: (void)0; /*placeholder for label*/ 
58205     { 
58206       unsigned Mem = 1 + addressToPC(MATCH_p);
58207       nextPC = 6 + MATCH_p; 
58208       
58209 #line 2035 "frontend/machine/pentium/decoder.m"
58210       
58211 
58212             stmts = instantiate(pc,  "FSTENV", DIS_MEM);
58213 
58214       
58215 
58216       
58217       
58218       
58219     } 
58220     goto MATCH_finished_c; 
58221     
58222   MATCH_label_c1115: (void)0; /*placeholder for label*/ 
58223     { 
58224       unsigned Mem16 = 1 + addressToPC(MATCH_p);
58225       nextPC = 3 + MATCH_p; 
58226       
58227 #line 2032 "frontend/machine/pentium/decoder.m"
58228       
58229 
58230             stmts = instantiate(pc,  "FSTCW", DIS_MEM16);
58231 
58232       
58233 
58234       
58235       
58236       
58237     } 
58238     goto MATCH_finished_c; 
58239     
58240   MATCH_label_c1116: (void)0; /*placeholder for label*/ 
58241     { 
58242       unsigned Mem16 = 1 + addressToPC(MATCH_p);
58243       nextPC = 7 + MATCH_p; 
58244       
58245 #line 2032 "frontend/machine/pentium/decoder.m"
58246       
58247 
58248             stmts = instantiate(pc,  "FSTCW", DIS_MEM16);
58249 
58250       
58251 
58252       
58253       
58254       
58255     } 
58256     goto MATCH_finished_c; 
58257     
58258   MATCH_label_c1117: (void)0; /*placeholder for label*/ 
58259     { 
58260       unsigned Mem16 = 1 + addressToPC(MATCH_p);
58261       nextPC = 6 + MATCH_p; 
58262       
58263 #line 2032 "frontend/machine/pentium/decoder.m"
58264       
58265 
58266             stmts = instantiate(pc,  "FSTCW", DIS_MEM16);
58267 
58268       
58269 
58270       
58271       
58272       
58273     } 
58274     goto MATCH_finished_c; 
58275     
58276   MATCH_label_c1118: (void)0; /*placeholder for label*/ 
58277     { 
58278       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58279       nextPC = 3 + MATCH_p; 
58280       
58281 #line 1775 "frontend/machine/pentium/decoder.m"
58282       
58283 
58284             stmts = instantiate(pc,  "FIADD.I32", DIS_MEM32);
58285 
58286       
58287 
58288       
58289       
58290       
58291     } 
58292     goto MATCH_finished_c; 
58293     
58294   MATCH_label_c1119: (void)0; /*placeholder for label*/ 
58295     { 
58296       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58297       nextPC = 7 + MATCH_p; 
58298       
58299 #line 1775 "frontend/machine/pentium/decoder.m"
58300       
58301 
58302             stmts = instantiate(pc,  "FIADD.I32", DIS_MEM32);
58303 
58304       
58305 
58306       
58307       
58308       
58309     } 
58310     goto MATCH_finished_c; 
58311     
58312   MATCH_label_c1120: (void)0; /*placeholder for label*/ 
58313     { 
58314       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58315       nextPC = 6 + MATCH_p; 
58316       
58317 #line 1775 "frontend/machine/pentium/decoder.m"
58318       
58319 
58320             stmts = instantiate(pc,  "FIADD.I32", DIS_MEM32);
58321 
58322       
58323 
58324       
58325       
58326       
58327     } 
58328     goto MATCH_finished_c; 
58329     
58330   MATCH_label_c1121: (void)0; /*placeholder for label*/ 
58331     { 
58332       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58333       nextPC = 3 + MATCH_p; 
58334       
58335 #line 1969 "frontend/machine/pentium/decoder.m"
58336       
58337 
58338             stmts = instantiate(pc,  "FIMUL.I32", DIS_MEM32);
58339 
58340       
58341 
58342       
58343       
58344       
58345     } 
58346     goto MATCH_finished_c; 
58347     
58348   MATCH_label_c1122: (void)0; /*placeholder for label*/ 
58349     { 
58350       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58351       nextPC = 7 + MATCH_p; 
58352       
58353 #line 1969 "frontend/machine/pentium/decoder.m"
58354       
58355 
58356             stmts = instantiate(pc,  "FIMUL.I32", DIS_MEM32);
58357 
58358       
58359 
58360       
58361       
58362       
58363     } 
58364     goto MATCH_finished_c; 
58365     
58366   MATCH_label_c1123: (void)0; /*placeholder for label*/ 
58367     { 
58368       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58369       nextPC = 6 + MATCH_p; 
58370       
58371 #line 1969 "frontend/machine/pentium/decoder.m"
58372       
58373 
58374             stmts = instantiate(pc,  "FIMUL.I32", DIS_MEM32);
58375 
58376       
58377 
58378       
58379       
58380       
58381     } 
58382     goto MATCH_finished_c; 
58383     
58384   MATCH_label_c1124: (void)0; /*placeholder for label*/ 
58385     { 
58386       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58387       nextPC = 3 + MATCH_p; 
58388       
58389 #line 1799 "frontend/machine/pentium/decoder.m"
58390       
58391 
58392             stmts = instantiate(pc,  "FICOM.I32", DIS_MEM32);
58393 
58394       
58395 
58396       
58397       
58398       
58399     } 
58400     goto MATCH_finished_c; 
58401     
58402   MATCH_label_c1125: (void)0; /*placeholder for label*/ 
58403     { 
58404       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58405       nextPC = 7 + MATCH_p; 
58406       
58407 #line 1799 "frontend/machine/pentium/decoder.m"
58408       
58409 
58410             stmts = instantiate(pc,  "FICOM.I32", DIS_MEM32);
58411 
58412       
58413 
58414       
58415       
58416       
58417     } 
58418     goto MATCH_finished_c; 
58419     
58420   MATCH_label_c1126: (void)0; /*placeholder for label*/ 
58421     { 
58422       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58423       nextPC = 6 + MATCH_p; 
58424       
58425 #line 1799 "frontend/machine/pentium/decoder.m"
58426       
58427 
58428             stmts = instantiate(pc,  "FICOM.I32", DIS_MEM32);
58429 
58430       
58431 
58432       
58433       
58434       
58435     } 
58436     goto MATCH_finished_c; 
58437     
58438   MATCH_label_c1127: (void)0; /*placeholder for label*/ 
58439     { 
58440       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58441       nextPC = 3 + MATCH_p; 
58442       
58443 #line 1817 "frontend/machine/pentium/decoder.m"
58444       
58445 
58446             stmts = instantiate(pc,  "FICOMP.I32", DIS_MEM32);
58447 
58448       
58449 
58450       
58451       
58452       
58453     } 
58454     goto MATCH_finished_c; 
58455     
58456   MATCH_label_c1128: (void)0; /*placeholder for label*/ 
58457     { 
58458       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58459       nextPC = 7 + MATCH_p; 
58460       
58461 #line 1817 "frontend/machine/pentium/decoder.m"
58462       
58463 
58464             stmts = instantiate(pc,  "FICOMP.I32", DIS_MEM32);
58465 
58466       
58467 
58468       
58469       
58470       
58471     } 
58472     goto MATCH_finished_c; 
58473     
58474   MATCH_label_c1129: (void)0; /*placeholder for label*/ 
58475     { 
58476       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58477       nextPC = 6 + MATCH_p; 
58478       
58479 #line 1817 "frontend/machine/pentium/decoder.m"
58480       
58481 
58482             stmts = instantiate(pc,  "FICOMP.I32", DIS_MEM32);
58483 
58484       
58485 
58486       
58487       
58488       
58489     } 
58490     goto MATCH_finished_c; 
58491     
58492   MATCH_label_c1130: (void)0; /*placeholder for label*/ 
58493     { 
58494       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58495       nextPC = 3 + MATCH_p; 
58496       
58497 #line 2056 "frontend/machine/pentium/decoder.m"
58498       
58499 
58500             stmts = instantiate(pc,  "FISUB.I32", DIS_MEM32);
58501 
58502       
58503 
58504       
58505       
58506       
58507     } 
58508     goto MATCH_finished_c; 
58509     
58510   MATCH_label_c1131: (void)0; /*placeholder for label*/ 
58511     { 
58512       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58513       nextPC = 7 + MATCH_p; 
58514       
58515 #line 2056 "frontend/machine/pentium/decoder.m"
58516       
58517 
58518             stmts = instantiate(pc,  "FISUB.I32", DIS_MEM32);
58519 
58520       
58521 
58522       
58523       
58524       
58525     } 
58526     goto MATCH_finished_c; 
58527     
58528   MATCH_label_c1132: (void)0; /*placeholder for label*/ 
58529     { 
58530       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58531       nextPC = 6 + MATCH_p; 
58532       
58533 #line 2056 "frontend/machine/pentium/decoder.m"
58534       
58535 
58536             stmts = instantiate(pc,  "FISUB.I32", DIS_MEM32);
58537 
58538       
58539 
58540       
58541       
58542       
58543     } 
58544     goto MATCH_finished_c; 
58545     
58546   MATCH_label_c1133: (void)0; /*placeholder for label*/ 
58547     { 
58548       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58549       nextPC = 3 + MATCH_p; 
58550       
58551 #line 2077 "frontend/machine/pentium/decoder.m"
58552       
58553 
58554             stmts = instantiate(pc,  "FISUBR.I32", DIS_MEM32);
58555 
58556       
58557 
58558       
58559       
58560       
58561     } 
58562     goto MATCH_finished_c; 
58563     
58564   MATCH_label_c1134: (void)0; /*placeholder for label*/ 
58565     { 
58566       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58567       nextPC = 7 + MATCH_p; 
58568       
58569 #line 2077 "frontend/machine/pentium/decoder.m"
58570       
58571 
58572             stmts = instantiate(pc,  "FISUBR.I32", DIS_MEM32);
58573 
58574       
58575 
58576       
58577       
58578       
58579     } 
58580     goto MATCH_finished_c; 
58581     
58582   MATCH_label_c1135: (void)0; /*placeholder for label*/ 
58583     { 
58584       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58585       nextPC = 6 + MATCH_p; 
58586       
58587 #line 2077 "frontend/machine/pentium/decoder.m"
58588       
58589 
58590             stmts = instantiate(pc,  "FISUBR.I32", DIS_MEM32);
58591 
58592       
58593 
58594       
58595       
58596       
58597     } 
58598     goto MATCH_finished_c; 
58599     
58600   MATCH_label_c1136: (void)0; /*placeholder for label*/ 
58601     { 
58602       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58603       nextPC = 3 + MATCH_p; 
58604       
58605 #line 1853 "frontend/machine/pentium/decoder.m"
58606       
58607 
58608             stmts = instantiate(pc,  "FIDIV.I32", DIS_MEM32);
58609 
58610       
58611 
58612       
58613       
58614       
58615     } 
58616     goto MATCH_finished_c; 
58617     
58618   MATCH_label_c1137: (void)0; /*placeholder for label*/ 
58619     { 
58620       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58621       nextPC = 7 + MATCH_p; 
58622       
58623 #line 1853 "frontend/machine/pentium/decoder.m"
58624       
58625 
58626             stmts = instantiate(pc,  "FIDIV.I32", DIS_MEM32);
58627 
58628       
58629 
58630       
58631       
58632       
58633     } 
58634     goto MATCH_finished_c; 
58635     
58636   MATCH_label_c1138: (void)0; /*placeholder for label*/ 
58637     { 
58638       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58639       nextPC = 6 + MATCH_p; 
58640       
58641 #line 1853 "frontend/machine/pentium/decoder.m"
58642       
58643 
58644             stmts = instantiate(pc,  "FIDIV.I32", DIS_MEM32);
58645 
58646       
58647 
58648       
58649       
58650       
58651     } 
58652     goto MATCH_finished_c; 
58653     
58654   MATCH_label_c1139: (void)0; /*placeholder for label*/ 
58655     { 
58656       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58657       nextPC = 3 + MATCH_p; 
58658       
58659 #line 1871 "frontend/machine/pentium/decoder.m"
58660       
58661 
58662             stmts = instantiate(pc,  "FIDIVR.I32", DIS_MEM32);
58663 
58664       
58665 
58666       
58667       
58668       
58669     } 
58670     goto MATCH_finished_c; 
58671     
58672   MATCH_label_c1140: (void)0; /*placeholder for label*/ 
58673     { 
58674       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58675       nextPC = 7 + MATCH_p; 
58676       
58677 #line 1871 "frontend/machine/pentium/decoder.m"
58678       
58679 
58680             stmts = instantiate(pc,  "FIDIVR.I32", DIS_MEM32);
58681 
58682       
58683 
58684       
58685       
58686       
58687     } 
58688     goto MATCH_finished_c; 
58689     
58690   MATCH_label_c1141: (void)0; /*placeholder for label*/ 
58691     { 
58692       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58693       nextPC = 6 + MATCH_p; 
58694       
58695 #line 1871 "frontend/machine/pentium/decoder.m"
58696       
58697 
58698             stmts = instantiate(pc,  "FIDIVR.I32", DIS_MEM32);
58699 
58700       
58701 
58702       
58703       
58704       
58705     } 
58706     goto MATCH_finished_c; 
58707     
58708   MATCH_label_c1142: (void)0; /*placeholder for label*/ 
58709     { 
58710       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58711       nextPC = 3 + MATCH_p; 
58712       
58713 #line 1886 "frontend/machine/pentium/decoder.m"
58714       
58715 
58716             stmts = instantiate(pc,  "FILD.lsI32", DIS_MEM32);
58717 
58718       
58719 
58720       
58721       
58722       
58723     } 
58724     goto MATCH_finished_c; 
58725     
58726   MATCH_label_c1143: (void)0; /*placeholder for label*/ 
58727     { 
58728       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58729       nextPC = 7 + MATCH_p; 
58730       
58731 #line 1886 "frontend/machine/pentium/decoder.m"
58732       
58733 
58734             stmts = instantiate(pc,  "FILD.lsI32", DIS_MEM32);
58735 
58736       
58737 
58738       
58739       
58740       
58741     } 
58742     goto MATCH_finished_c; 
58743     
58744   MATCH_label_c1144: (void)0; /*placeholder for label*/ 
58745     { 
58746       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58747       nextPC = 6 + MATCH_p; 
58748       
58749 #line 1886 "frontend/machine/pentium/decoder.m"
58750       
58751 
58752             stmts = instantiate(pc,  "FILD.lsI32", DIS_MEM32);
58753 
58754       
58755 
58756       
58757       
58758       
58759     } 
58760     goto MATCH_finished_c; 
58761     
58762   MATCH_label_c1145: (void)0; /*placeholder for label*/ 
58763     { 
58764       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58765       nextPC = 3 + MATCH_p; 
58766       
58767 #line 1898 "frontend/machine/pentium/decoder.m"
58768       
58769 
58770             stmts = instantiate(pc,  "FIST.lsI32", DIS_MEM32);
58771 
58772       
58773 
58774       
58775       
58776       
58777     } 
58778     goto MATCH_finished_c; 
58779     
58780   MATCH_label_c1146: (void)0; /*placeholder for label*/ 
58781     { 
58782       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58783       nextPC = 7 + MATCH_p; 
58784       
58785 #line 1898 "frontend/machine/pentium/decoder.m"
58786       
58787 
58788             stmts = instantiate(pc,  "FIST.lsI32", DIS_MEM32);
58789 
58790       
58791 
58792       
58793       
58794       
58795     } 
58796     goto MATCH_finished_c; 
58797     
58798   MATCH_label_c1147: (void)0; /*placeholder for label*/ 
58799     { 
58800       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58801       nextPC = 6 + MATCH_p; 
58802       
58803 #line 1898 "frontend/machine/pentium/decoder.m"
58804       
58805 
58806             stmts = instantiate(pc,  "FIST.lsI32", DIS_MEM32);
58807 
58808       
58809 
58810       
58811       
58812       
58813     } 
58814     goto MATCH_finished_c; 
58815     
58816   MATCH_label_c1148: (void)0; /*placeholder for label*/ 
58817     { 
58818       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58819       nextPC = 3 + MATCH_p; 
58820       
58821 #line 1904 "frontend/machine/pentium/decoder.m"
58822       
58823 
58824             stmts = instantiate(pc,  "FISTP.lsI32", DIS_MEM32);
58825 
58826       
58827 
58828       
58829       
58830       
58831     } 
58832     goto MATCH_finished_c; 
58833     
58834   MATCH_label_c1149: (void)0; /*placeholder for label*/ 
58835     { 
58836       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58837       nextPC = 7 + MATCH_p; 
58838       
58839 #line 1904 "frontend/machine/pentium/decoder.m"
58840       
58841 
58842             stmts = instantiate(pc,  "FISTP.lsI32", DIS_MEM32);
58843 
58844       
58845 
58846       
58847       
58848       
58849     } 
58850     goto MATCH_finished_c; 
58851     
58852   MATCH_label_c1150: (void)0; /*placeholder for label*/ 
58853     { 
58854       unsigned Mem32 = 1 + addressToPC(MATCH_p);
58855       nextPC = 6 + MATCH_p; 
58856       
58857 #line 1904 "frontend/machine/pentium/decoder.m"
58858       
58859 
58860             stmts = instantiate(pc,  "FISTP.lsI32", DIS_MEM32);
58861 
58862       
58863 
58864       
58865       
58866       
58867     } 
58868     goto MATCH_finished_c; 
58869     
58870   MATCH_label_c1151: (void)0; /*placeholder for label*/ 
58871     { 
58872       unsigned Mem80 = 1 + addressToPC(MATCH_p);
58873       nextPC = 3 + MATCH_p; 
58874       
58875 #line 1916 "frontend/machine/pentium/decoder.m"
58876       
58877 
58878             stmts = instantiate(pc,  "FLD80", DIS_MEM80);
58879 
58880       
58881 
58882       /* This is a bit tricky. The FPUSH logically comes between the read of STi and
58883 
58884       # the write to ST0. In particular, FLD ST0 is supposed to duplicate the TOS.
58885 
58886       # This problem only happens with this load instruction, so there is a work
58887 
58888       # around here that gives us the SSL a value of i that is one more than in
58889 
58890       # the instruction */
58891 
58892       
58893       
58894       
58895     } 
58896     goto MATCH_finished_c; 
58897     
58898   MATCH_label_c1152: (void)0; /*placeholder for label*/ 
58899     { 
58900       unsigned Mem80 = 1 + addressToPC(MATCH_p);
58901       nextPC = 7 + MATCH_p; 
58902       
58903 #line 1916 "frontend/machine/pentium/decoder.m"
58904       
58905 
58906             stmts = instantiate(pc,  "FLD80", DIS_MEM80);
58907 
58908       
58909 
58910       /* This is a bit tricky. The FPUSH logically comes between the read of STi and
58911 
58912       # the write to ST0. In particular, FLD ST0 is supposed to duplicate the TOS.
58913 
58914       # This problem only happens with this load instruction, so there is a work
58915 
58916       # around here that gives us the SSL a value of i that is one more than in
58917 
58918       # the instruction */
58919 
58920       
58921       
58922       
58923     } 
58924     goto MATCH_finished_c; 
58925     
58926   MATCH_label_c1153: (void)0; /*placeholder for label*/ 
58927     { 
58928       unsigned Mem80 = 1 + addressToPC(MATCH_p);
58929       nextPC = 6 + MATCH_p; 
58930       
58931 #line 1916 "frontend/machine/pentium/decoder.m"
58932       
58933 
58934             stmts = instantiate(pc,  "FLD80", DIS_MEM80);
58935 
58936       
58937 
58938       /* This is a bit tricky. The FPUSH logically comes between the read of STi and
58939 
58940       # the write to ST0. In particular, FLD ST0 is supposed to duplicate the TOS.
58941 
58942       # This problem only happens with this load instruction, so there is a work
58943 
58944       # around here that gives us the SSL a value of i that is one more than in
58945 
58946       # the instruction */
58947 
58948       
58949       
58950       
58951     } 
58952     goto MATCH_finished_c; 
58953     
58954   MATCH_label_c1154: (void)0; /*placeholder for label*/ 
58955     { 
58956       unsigned Mem80 = 1 + addressToPC(MATCH_p);
58957       nextPC = 3 + MATCH_p; 
58958       
58959 #line 2023 "frontend/machine/pentium/decoder.m"
58960       
58961 
58962             stmts = instantiate(pc,  "FSTP80", DIS_MEM80);
58963 
58964       
58965 
58966       
58967       
58968       
58969     } 
58970     goto MATCH_finished_c; 
58971     
58972   MATCH_label_c1155: (void)0; /*placeholder for label*/ 
58973     { 
58974       unsigned Mem80 = 1 + addressToPC(MATCH_p);
58975       nextPC = 7 + MATCH_p; 
58976       
58977 #line 2023 "frontend/machine/pentium/decoder.m"
58978       
58979 
58980             stmts = instantiate(pc,  "FSTP80", DIS_MEM80);
58981 
58982       
58983 
58984       
58985       
58986       
58987     } 
58988     goto MATCH_finished_c; 
58989     
58990   MATCH_label_c1156: (void)0; /*placeholder for label*/ 
58991     { 
58992       unsigned Mem80 = 1 + addressToPC(MATCH_p);
58993       nextPC = 6 + MATCH_p; 
58994       
58995 #line 2023 "frontend/machine/pentium/decoder.m"
58996       
58997 
58998             stmts = instantiate(pc,  "FSTP80", DIS_MEM80);
58999 
59000       
59001 
59002       
59003       
59004       
59005     } 
59006     goto MATCH_finished_c; 
59007     
59008   MATCH_label_c1157: (void)0; /*placeholder for label*/ 
59009     { 
59010       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59011       nextPC = 3 + MATCH_p; 
59012       
59013 #line 1763 "frontend/machine/pentium/decoder.m"
59014       
59015 
59016             stmts = instantiate(pc,  "FADD.R64", DIS_MEM64);
59017 
59018       
59019 
59020       
59021       
59022       
59023     } 
59024     goto MATCH_finished_c; 
59025     
59026   MATCH_label_c1158: (void)0; /*placeholder for label*/ 
59027     { 
59028       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59029       nextPC = 7 + MATCH_p; 
59030       
59031 #line 1763 "frontend/machine/pentium/decoder.m"
59032       
59033 
59034             stmts = instantiate(pc,  "FADD.R64", DIS_MEM64);
59035 
59036       
59037 
59038       
59039       
59040       
59041     } 
59042     goto MATCH_finished_c; 
59043     
59044   MATCH_label_c1159: (void)0; /*placeholder for label*/ 
59045     { 
59046       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59047       nextPC = 6 + MATCH_p; 
59048       
59049 #line 1763 "frontend/machine/pentium/decoder.m"
59050       
59051 
59052             stmts = instantiate(pc,  "FADD.R64", DIS_MEM64);
59053 
59054       
59055 
59056       
59057       
59058       
59059     } 
59060     goto MATCH_finished_c; 
59061     
59062   MATCH_label_c1160: (void)0; /*placeholder for label*/ 
59063     { 
59064       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59065       nextPC = 3 + MATCH_p; 
59066       
59067 #line 1957 "frontend/machine/pentium/decoder.m"
59068       
59069 
59070             stmts = instantiate(pc,  "FMUL.R64", DIS_MEM64);
59071 
59072       
59073 
59074       
59075       
59076       
59077     } 
59078     goto MATCH_finished_c; 
59079     
59080   MATCH_label_c1161: (void)0; /*placeholder for label*/ 
59081     { 
59082       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59083       nextPC = 7 + MATCH_p; 
59084       
59085 #line 1957 "frontend/machine/pentium/decoder.m"
59086       
59087 
59088             stmts = instantiate(pc,  "FMUL.R64", DIS_MEM64);
59089 
59090       
59091 
59092       
59093       
59094       
59095     } 
59096     goto MATCH_finished_c; 
59097     
59098   MATCH_label_c1162: (void)0; /*placeholder for label*/ 
59099     { 
59100       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59101       nextPC = 6 + MATCH_p; 
59102       
59103 #line 1957 "frontend/machine/pentium/decoder.m"
59104       
59105 
59106             stmts = instantiate(pc,  "FMUL.R64", DIS_MEM64);
59107 
59108       
59109 
59110       
59111       
59112       
59113     } 
59114     goto MATCH_finished_c; 
59115     
59116   MATCH_label_c1163: (void)0; /*placeholder for label*/ 
59117     { 
59118       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59119       nextPC = 3 + MATCH_p; 
59120       
59121 #line 1796 "frontend/machine/pentium/decoder.m"
59122       
59123 
59124             stmts = instantiate(pc,  "FCOM.R64", DIS_MEM64);
59125 
59126       
59127 
59128       
59129       
59130       
59131     } 
59132     goto MATCH_finished_c; 
59133     
59134   MATCH_label_c1164: (void)0; /*placeholder for label*/ 
59135     { 
59136       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59137       nextPC = 7 + MATCH_p; 
59138       
59139 #line 1796 "frontend/machine/pentium/decoder.m"
59140       
59141 
59142             stmts = instantiate(pc,  "FCOM.R64", DIS_MEM64);
59143 
59144       
59145 
59146       
59147       
59148       
59149     } 
59150     goto MATCH_finished_c; 
59151     
59152   MATCH_label_c1165: (void)0; /*placeholder for label*/ 
59153     { 
59154       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59155       nextPC = 6 + MATCH_p; 
59156       
59157 #line 1796 "frontend/machine/pentium/decoder.m"
59158       
59159 
59160             stmts = instantiate(pc,  "FCOM.R64", DIS_MEM64);
59161 
59162       
59163 
59164       
59165       
59166       
59167     } 
59168     goto MATCH_finished_c; 
59169     
59170   MATCH_label_c1166: (void)0; /*placeholder for label*/ 
59171     { 
59172       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59173       nextPC = 3 + MATCH_p; 
59174       
59175 #line 1808 "frontend/machine/pentium/decoder.m"
59176       
59177 
59178             stmts = instantiate(pc,  "FCOMP.R64", DIS_MEM64);
59179 
59180       
59181 
59182       
59183       
59184       
59185     } 
59186     goto MATCH_finished_c; 
59187     
59188   MATCH_label_c1167: (void)0; /*placeholder for label*/ 
59189     { 
59190       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59191       nextPC = 7 + MATCH_p; 
59192       
59193 #line 1808 "frontend/machine/pentium/decoder.m"
59194       
59195 
59196             stmts = instantiate(pc,  "FCOMP.R64", DIS_MEM64);
59197 
59198       
59199 
59200       
59201       
59202       
59203     } 
59204     goto MATCH_finished_c; 
59205     
59206   MATCH_label_c1168: (void)0; /*placeholder for label*/ 
59207     { 
59208       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59209       nextPC = 6 + MATCH_p; 
59210       
59211 #line 1808 "frontend/machine/pentium/decoder.m"
59212       
59213 
59214             stmts = instantiate(pc,  "FCOMP.R64", DIS_MEM64);
59215 
59216       
59217 
59218       
59219       
59220       
59221     } 
59222     goto MATCH_finished_c; 
59223     
59224   MATCH_label_c1169: (void)0; /*placeholder for label*/ 
59225     { 
59226       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59227       nextPC = 3 + MATCH_p; 
59228       
59229 #line 2047 "frontend/machine/pentium/decoder.m"
59230       
59231 
59232             stmts = instantiate(pc,  "FSUB.R64", DIS_MEM64);
59233 
59234       
59235 
59236       
59237       
59238       
59239     } 
59240     goto MATCH_finished_c; 
59241     
59242   MATCH_label_c1170: (void)0; /*placeholder for label*/ 
59243     { 
59244       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59245       nextPC = 7 + MATCH_p; 
59246       
59247 #line 2047 "frontend/machine/pentium/decoder.m"
59248       
59249 
59250             stmts = instantiate(pc,  "FSUB.R64", DIS_MEM64);
59251 
59252       
59253 
59254       
59255       
59256       
59257     } 
59258     goto MATCH_finished_c; 
59259     
59260   MATCH_label_c1171: (void)0; /*placeholder for label*/ 
59261     { 
59262       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59263       nextPC = 6 + MATCH_p; 
59264       
59265 #line 2047 "frontend/machine/pentium/decoder.m"
59266       
59267 
59268             stmts = instantiate(pc,  "FSUB.R64", DIS_MEM64);
59269 
59270       
59271 
59272       
59273       
59274       
59275     } 
59276     goto MATCH_finished_c; 
59277     
59278   MATCH_label_c1172: (void)0; /*placeholder for label*/ 
59279     { 
59280       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59281       nextPC = 3 + MATCH_p; 
59282       
59283 #line 2068 "frontend/machine/pentium/decoder.m"
59284       
59285 
59286             stmts = instantiate(pc,  "FSUBR.R64", DIS_MEM64);
59287 
59288       
59289 
59290       
59291       
59292       
59293     } 
59294     goto MATCH_finished_c; 
59295     
59296   MATCH_label_c1173: (void)0; /*placeholder for label*/ 
59297     { 
59298       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59299       nextPC = 7 + MATCH_p; 
59300       
59301 #line 2068 "frontend/machine/pentium/decoder.m"
59302       
59303 
59304             stmts = instantiate(pc,  "FSUBR.R64", DIS_MEM64);
59305 
59306       
59307 
59308       
59309       
59310       
59311     } 
59312     goto MATCH_finished_c; 
59313     
59314   MATCH_label_c1174: (void)0; /*placeholder for label*/ 
59315     { 
59316       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59317       nextPC = 6 + MATCH_p; 
59318       
59319 #line 2068 "frontend/machine/pentium/decoder.m"
59320       
59321 
59322             stmts = instantiate(pc,  "FSUBR.R64", DIS_MEM64);
59323 
59324       
59325 
59326       
59327       
59328       
59329     } 
59330     goto MATCH_finished_c; 
59331     
59332   MATCH_label_c1175: (void)0; /*placeholder for label*/ 
59333     { 
59334       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59335       nextPC = 3 + MATCH_p; 
59336       
59337 #line 1841 "frontend/machine/pentium/decoder.m"
59338       
59339 
59340             stmts = instantiate(pc,  "FDIV.R64", DIS_MEM64);
59341 
59342       
59343 
59344       
59345       
59346       
59347     } 
59348     goto MATCH_finished_c; 
59349     
59350   MATCH_label_c1176: (void)0; /*placeholder for label*/ 
59351     { 
59352       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59353       nextPC = 7 + MATCH_p; 
59354       
59355 #line 1841 "frontend/machine/pentium/decoder.m"
59356       
59357 
59358             stmts = instantiate(pc,  "FDIV.R64", DIS_MEM64);
59359 
59360       
59361 
59362       
59363       
59364       
59365     } 
59366     goto MATCH_finished_c; 
59367     
59368   MATCH_label_c1177: (void)0; /*placeholder for label*/ 
59369     { 
59370       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59371       nextPC = 6 + MATCH_p; 
59372       
59373 #line 1841 "frontend/machine/pentium/decoder.m"
59374       
59375 
59376             stmts = instantiate(pc,  "FDIV.R64", DIS_MEM64);
59377 
59378       
59379 
59380       
59381       
59382       
59383     } 
59384     goto MATCH_finished_c; 
59385     
59386   MATCH_label_c1178: (void)0; /*placeholder for label*/ 
59387     { 
59388       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59389       nextPC = 3 + MATCH_p; 
59390       
59391 #line 1862 "frontend/machine/pentium/decoder.m"
59392       
59393 
59394             stmts = instantiate(pc,  "FDIVR.R64", DIS_MEM64);
59395 
59396       
59397 
59398       
59399       
59400       
59401     } 
59402     goto MATCH_finished_c; 
59403     
59404   MATCH_label_c1179: (void)0; /*placeholder for label*/ 
59405     { 
59406       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59407       nextPC = 7 + MATCH_p; 
59408       
59409 #line 1862 "frontend/machine/pentium/decoder.m"
59410       
59411 
59412             stmts = instantiate(pc,  "FDIVR.R64", DIS_MEM64);
59413 
59414       
59415 
59416       
59417       
59418       
59419     } 
59420     goto MATCH_finished_c; 
59421     
59422   MATCH_label_c1180: (void)0; /*placeholder for label*/ 
59423     { 
59424       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59425       nextPC = 6 + MATCH_p; 
59426       
59427 #line 1862 "frontend/machine/pentium/decoder.m"
59428       
59429 
59430             stmts = instantiate(pc,  "FDIVR.R64", DIS_MEM64);
59431 
59432       
59433 
59434       
59435       
59436       
59437     } 
59438     goto MATCH_finished_c; 
59439     
59440   MATCH_label_c1181: (void)0; /*placeholder for label*/ 
59441     { 
59442       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59443       nextPC = 3 + MATCH_p; 
59444       
59445 #line 1913 "frontend/machine/pentium/decoder.m"
59446       
59447 
59448             stmts = instantiate(pc,  "FLD.lsR64", DIS_MEM64);
59449 
59450       
59451 
59452       
59453       
59454       
59455     } 
59456     goto MATCH_finished_c; 
59457     
59458   MATCH_label_c1182: (void)0; /*placeholder for label*/ 
59459     { 
59460       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59461       nextPC = 7 + MATCH_p; 
59462       
59463 #line 1913 "frontend/machine/pentium/decoder.m"
59464       
59465 
59466             stmts = instantiate(pc,  "FLD.lsR64", DIS_MEM64);
59467 
59468       
59469 
59470       
59471       
59472       
59473     } 
59474     goto MATCH_finished_c; 
59475     
59476   MATCH_label_c1183: (void)0; /*placeholder for label*/ 
59477     { 
59478       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59479       nextPC = 6 + MATCH_p; 
59480       
59481 #line 1913 "frontend/machine/pentium/decoder.m"
59482       
59483 
59484             stmts = instantiate(pc,  "FLD.lsR64", DIS_MEM64);
59485 
59486       
59487 
59488       
59489       
59490       
59491     } 
59492     goto MATCH_finished_c; 
59493     
59494   MATCH_label_c1184: (void)0; /*placeholder for label*/ 
59495     { 
59496       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59497       nextPC = 3 + MATCH_p; 
59498       
59499 #line 2014 "frontend/machine/pentium/decoder.m"
59500       
59501 
59502             stmts = instantiate(pc,  "FST.lsR64", DIS_MEM64);
59503 
59504       
59505 
59506       
59507       
59508       
59509     } 
59510     goto MATCH_finished_c; 
59511     
59512   MATCH_label_c1185: (void)0; /*placeholder for label*/ 
59513     { 
59514       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59515       nextPC = 7 + MATCH_p; 
59516       
59517 #line 2014 "frontend/machine/pentium/decoder.m"
59518       
59519 
59520             stmts = instantiate(pc,  "FST.lsR64", DIS_MEM64);
59521 
59522       
59523 
59524       
59525       
59526       
59527     } 
59528     goto MATCH_finished_c; 
59529     
59530   MATCH_label_c1186: (void)0; /*placeholder for label*/ 
59531     { 
59532       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59533       nextPC = 6 + MATCH_p; 
59534       
59535 #line 2014 "frontend/machine/pentium/decoder.m"
59536       
59537 
59538             stmts = instantiate(pc,  "FST.lsR64", DIS_MEM64);
59539 
59540       
59541 
59542       
59543       
59544       
59545     } 
59546     goto MATCH_finished_c; 
59547     
59548   MATCH_label_c1187: (void)0; /*placeholder for label*/ 
59549     { 
59550       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59551       nextPC = 3 + MATCH_p; 
59552       
59553 #line 2020 "frontend/machine/pentium/decoder.m"
59554       
59555 
59556             stmts = instantiate(pc,  "FSTP.lsR64", DIS_MEM64);
59557 
59558       
59559 
59560       
59561       
59562       
59563     } 
59564     goto MATCH_finished_c; 
59565     
59566   MATCH_label_c1188: (void)0; /*placeholder for label*/ 
59567     { 
59568       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59569       nextPC = 7 + MATCH_p; 
59570       
59571 #line 2020 "frontend/machine/pentium/decoder.m"
59572       
59573 
59574             stmts = instantiate(pc,  "FSTP.lsR64", DIS_MEM64);
59575 
59576       
59577 
59578       
59579       
59580       
59581     } 
59582     goto MATCH_finished_c; 
59583     
59584   MATCH_label_c1189: (void)0; /*placeholder for label*/ 
59585     { 
59586       unsigned Mem64 = 1 + addressToPC(MATCH_p);
59587       nextPC = 6 + MATCH_p; 
59588       
59589 #line 2020 "frontend/machine/pentium/decoder.m"
59590       
59591 
59592             stmts = instantiate(pc,  "FSTP.lsR64", DIS_MEM64);
59593 
59594       
59595 
59596       
59597       
59598       
59599     } 
59600     goto MATCH_finished_c; 
59601     
59602   MATCH_label_c1190: (void)0; /*placeholder for label*/ 
59603     { 
59604       unsigned Mem = 1 + addressToPC(MATCH_p);
59605       nextPC = 3 + MATCH_p; 
59606       
59607 #line 1993 "frontend/machine/pentium/decoder.m"
59608       
59609 
59610             stmts = instantiate(pc,  "FRSTOR", DIS_MEM);
59611 
59612       
59613 
59614       
59615       
59616       
59617     } 
59618     goto MATCH_finished_c; 
59619     
59620   MATCH_label_c1191: (void)0; /*placeholder for label*/ 
59621     { 
59622       unsigned Mem = 1 + addressToPC(MATCH_p);
59623       nextPC = 7 + MATCH_p; 
59624       
59625 #line 1993 "frontend/machine/pentium/decoder.m"
59626       
59627 
59628             stmts = instantiate(pc,  "FRSTOR", DIS_MEM);
59629 
59630       
59631 
59632       
59633       
59634       
59635     } 
59636     goto MATCH_finished_c; 
59637     
59638   MATCH_label_c1192: (void)0; /*placeholder for label*/ 
59639     { 
59640       unsigned Mem = 1 + addressToPC(MATCH_p);
59641       nextPC = 6 + MATCH_p; 
59642       
59643 #line 1993 "frontend/machine/pentium/decoder.m"
59644       
59645 
59646             stmts = instantiate(pc,  "FRSTOR", DIS_MEM);
59647 
59648       
59649 
59650       
59651       
59652       
59653     } 
59654     goto MATCH_finished_c; 
59655     
59656   MATCH_label_c1193: (void)0; /*placeholder for label*/ 
59657     { 
59658       unsigned Mem = 1 + addressToPC(MATCH_p);
59659       nextPC = 3 + MATCH_p; 
59660       
59661 #line 1996 "frontend/machine/pentium/decoder.m"
59662       
59663 
59664             stmts = instantiate(pc,  "FNSAVE", DIS_MEM);
59665 
59666       
59667 
59668       
59669       
59670       
59671     } 
59672     goto MATCH_finished_c; 
59673     
59674   MATCH_label_c1194: (void)0; /*placeholder for label*/ 
59675     { 
59676       unsigned Mem = 1 + addressToPC(MATCH_p);
59677       nextPC = 7 + MATCH_p; 
59678       
59679 #line 1996 "frontend/machine/pentium/decoder.m"
59680       
59681 
59682             stmts = instantiate(pc,  "FNSAVE", DIS_MEM);
59683 
59684       
59685 
59686       
59687       
59688       
59689     } 
59690     goto MATCH_finished_c; 
59691     
59692   MATCH_label_c1195: (void)0; /*placeholder for label*/ 
59693     { 
59694       unsigned Mem = 1 + addressToPC(MATCH_p);
59695       nextPC = 6 + MATCH_p; 
59696       
59697 #line 1996 "frontend/machine/pentium/decoder.m"
59698       
59699 
59700             stmts = instantiate(pc,  "FNSAVE", DIS_MEM);
59701 
59702       
59703 
59704       
59705       
59706       
59707     } 
59708     goto MATCH_finished_c; 
59709     
59710   MATCH_label_c1196: (void)0; /*placeholder for label*/ 
59711     { 
59712       unsigned Mem16 = 1 + addressToPC(MATCH_p);
59713       nextPC = 3 + MATCH_p; 
59714       
59715 #line 2038 "frontend/machine/pentium/decoder.m"
59716       
59717 
59718             stmts = instantiate(pc,  "FSTSW", DIS_MEM16);
59719 
59720       
59721 
59722       
59723       
59724       
59725     } 
59726     goto MATCH_finished_c; 
59727     
59728   MATCH_label_c1197: (void)0; /*placeholder for label*/ 
59729     { 
59730       unsigned Mem16 = 1 + addressToPC(MATCH_p);
59731       nextPC = 7 + MATCH_p; 
59732       
59733 #line 2038 "frontend/machine/pentium/decoder.m"
59734       
59735 
59736             stmts = instantiate(pc,  "FSTSW", DIS_MEM16);
59737 
59738       
59739 
59740       
59741       
59742       
59743     } 
59744     goto MATCH_finished_c; 
59745     
59746   MATCH_label_c1198: (void)0; /*placeholder for label*/ 
59747     { 
59748       unsigned Mem16 = 1 + addressToPC(MATCH_p);
59749       nextPC = 6 + MATCH_p; 
59750       
59751 #line 2038 "frontend/machine/pentium/decoder.m"
59752       
59753 
59754             stmts = instantiate(pc,  "FSTSW", DIS_MEM16);
59755 
59756       
59757 
59758       
59759       
59760       
59761     } 
59762     goto MATCH_finished_c; 
59763     
59764   MATCH_label_c1199: (void)0; /*placeholder for label*/ 
59765     { 
59766       unsigned Mem16 = 1 + addressToPC(MATCH_p);
59767       nextPC = 3 + MATCH_p; 
59768       
59769 #line 1778 "frontend/machine/pentium/decoder.m"
59770       
59771 
59772             stmts = instantiate(pc,  "FIADD.I16", DIS_MEM16);
59773 
59774       
59775 
59776       
59777       
59778       
59779     } 
59780     goto MATCH_finished_c; 
59781     
59782   MATCH_label_c1200: (void)0; /*placeholder for label*/ 
59783     { 
59784       unsigned Mem16 = 1 + addressToPC(MATCH_p);
59785       nextPC = 7 + MATCH_p; 
59786       
59787 #line 1778 "frontend/machine/pentium/decoder.m"
59788       
59789 
59790             stmts = instantiate(pc,  "FIADD.I16", DIS_MEM16);
59791 
59792       
59793 
59794       
59795       
59796       
59797     } 
59798     goto MATCH_finished_c; 
59799     
59800   MATCH_label_c1201: (void)0; /*placeholder for label*/ 
59801     { 
59802       unsigned Mem16 = 1 + addressToPC(MATCH_p);
59803       nextPC = 6 + MATCH_p; 
59804       
59805 #line 1778 "frontend/machine/pentium/decoder.m"
59806       
59807 
59808             stmts = instantiate(pc,  "FIADD.I16", DIS_MEM16);
59809 
59810       
59811 
59812       
59813       
59814       
59815     } 
59816     goto MATCH_finished_c; 
59817     
59818   MATCH_label_c1202: (void)0; /*placeholder for label*/ 
59819     { 
59820       unsigned Mem16 = 1 + addressToPC(MATCH_p);
59821       nextPC = 3 + MATCH_p; 
59822       
59823 #line 1972 "frontend/machine/pentium/decoder.m"
59824       
59825 
59826             stmts = instantiate(pc,  "FIMUL.I16", DIS_MEM16);
59827 
59828       
59829 
59830       
59831       
59832       
59833     } 
59834     goto MATCH_finished_c; 
59835     
59836   MATCH_label_c1203: (void)0; /*placeholder for label*/ 
59837     { 
59838       unsigned Mem16 = 1 + addressToPC(MATCH_p);
59839       nextPC = 7 + MATCH_p; 
59840       
59841 #line 1972 "frontend/machine/pentium/decoder.m"
59842       
59843 
59844             stmts = instantiate(pc,  "FIMUL.I16", DIS_MEM16);
59845 
59846       
59847 
59848       
59849       
59850       
59851     } 
59852     goto MATCH_finished_c; 
59853     
59854   MATCH_label_c1204: (void)0; /*placeholder for label*/ 
59855     { 
59856       unsigned Mem16 = 1 + addressToPC(MATCH_p);
59857       nextPC = 6 + MATCH_p; 
59858       
59859 #line 1972 "frontend/machine/pentium/decoder.m"
59860       
59861 
59862             stmts = instantiate(pc,  "FIMUL.I16", DIS_MEM16);
59863 
59864       
59865 
59866       
59867       
59868       
59869     } 
59870     goto MATCH_finished_c; 
59871     
59872   MATCH_label_c1205: (void)0; /*placeholder for label*/ 
59873     { 
59874       unsigned Mem16 = 1 + addressToPC(MATCH_p);
59875       nextPC = 3 + MATCH_p; 
59876       
59877 #line 1802 "frontend/machine/pentium/decoder.m"
59878       
59879 
59880             stmts = instantiate(pc,  "FICOM.I16", DIS_MEM16);
59881 
59882       
59883 
59884       
59885       
59886       
59887     } 
59888     goto MATCH_finished_c; 
59889     
59890   MATCH_label_c1206: (void)0; /*placeholder for label*/ 
59891     { 
59892       unsigned Mem16 = 1 + addressToPC(MATCH_p);
59893       nextPC = 7 + MATCH_p; 
59894       
59895 #line 1802 "frontend/machine/pentium/decoder.m"
59896       
59897 
59898             stmts = instantiate(pc,  "FICOM.I16", DIS_MEM16);
59899 
59900       
59901 
59902       
59903       
59904       
59905     } 
59906     goto MATCH_finished_c; 
59907     
59908   MATCH_label_c1207: (void)0; /*placeholder for label*/ 
59909     { 
59910       unsigned Mem16 = 1 + addressToPC(MATCH_p);
59911       nextPC = 6 + MATCH_p; 
59912       
59913 #line 1802 "frontend/machine/pentium/decoder.m"
59914       
59915 
59916             stmts = instantiate(pc,  "FICOM.I16", DIS_MEM16);
59917 
59918       
59919 
59920       
59921       
59922       
59923     } 
59924     goto MATCH_finished_c; 
59925     
59926   MATCH_label_c1208: (void)0; /*placeholder for label*/ 
59927     { 
59928       unsigned Mem16 = 1 + addressToPC(MATCH_p);
59929       nextPC = 3 + MATCH_p; 
59930       
59931 #line 1820 "frontend/machine/pentium/decoder.m"
59932       
59933 
59934             stmts = instantiate(pc,  "FICOMP.I16", DIS_MEM16);
59935 
59936       
59937 
59938       
59939       
59940       
59941     } 
59942     goto MATCH_finished_c; 
59943     
59944   MATCH_label_c1209: (void)0; /*placeholder for label*/ 
59945     { 
59946       unsigned Mem16 = 1 + addressToPC(MATCH_p);
59947       nextPC = 7 + MATCH_p; 
59948       
59949 #line 1820 "frontend/machine/pentium/decoder.m"
59950       
59951 
59952             stmts = instantiate(pc,  "FICOMP.I16", DIS_MEM16);
59953 
59954       
59955 
59956       
59957       
59958       
59959     } 
59960     goto MATCH_finished_c; 
59961     
59962   MATCH_label_c1210: (void)0; /*placeholder for label*/ 
59963     { 
59964       unsigned Mem16 = 1 + addressToPC(MATCH_p);
59965       nextPC = 6 + MATCH_p; 
59966       
59967 #line 1820 "frontend/machine/pentium/decoder.m"
59968       
59969 
59970             stmts = instantiate(pc,  "FICOMP.I16", DIS_MEM16);
59971 
59972       
59973 
59974       
59975       
59976       
59977     } 
59978     goto MATCH_finished_c; 
59979     
59980   MATCH_label_c1211: (void)0; /*placeholder for label*/ 
59981     { 
59982       unsigned Mem16 = 1 + addressToPC(MATCH_p);
59983       nextPC = 3 + MATCH_p; 
59984       
59985 #line 2059 "frontend/machine/pentium/decoder.m"
59986       
59987 
59988             stmts = instantiate(pc,  "FISUB.I16", DIS_MEM16);
59989 
59990       
59991 
59992       
59993       
59994       
59995     } 
59996     goto MATCH_finished_c; 
59997     
59998   MATCH_label_c1212: (void)0; /*placeholder for label*/ 
59999     { 
60000       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60001       nextPC = 7 + MATCH_p; 
60002       
60003 #line 2059 "frontend/machine/pentium/decoder.m"
60004       
60005 
60006             stmts = instantiate(pc,  "FISUB.I16", DIS_MEM16);
60007 
60008       
60009 
60010       
60011       
60012       
60013     } 
60014     goto MATCH_finished_c; 
60015     
60016   MATCH_label_c1213: (void)0; /*placeholder for label*/ 
60017     { 
60018       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60019       nextPC = 6 + MATCH_p; 
60020       
60021 #line 2059 "frontend/machine/pentium/decoder.m"
60022       
60023 
60024             stmts = instantiate(pc,  "FISUB.I16", DIS_MEM16);
60025 
60026       
60027 
60028       
60029       
60030       
60031     } 
60032     goto MATCH_finished_c; 
60033     
60034   MATCH_label_c1214: (void)0; /*placeholder for label*/ 
60035     { 
60036       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60037       nextPC = 3 + MATCH_p; 
60038       
60039 #line 2080 "frontend/machine/pentium/decoder.m"
60040       
60041 
60042             stmts = instantiate(pc,  "FISUBR.I16", DIS_MEM16);
60043 
60044       
60045 
60046       
60047       
60048       
60049     } 
60050     goto MATCH_finished_c; 
60051     
60052   MATCH_label_c1215: (void)0; /*placeholder for label*/ 
60053     { 
60054       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60055       nextPC = 7 + MATCH_p; 
60056       
60057 #line 2080 "frontend/machine/pentium/decoder.m"
60058       
60059 
60060             stmts = instantiate(pc,  "FISUBR.I16", DIS_MEM16);
60061 
60062       
60063 
60064       
60065       
60066       
60067     } 
60068     goto MATCH_finished_c; 
60069     
60070   MATCH_label_c1216: (void)0; /*placeholder for label*/ 
60071     { 
60072       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60073       nextPC = 6 + MATCH_p; 
60074       
60075 #line 2080 "frontend/machine/pentium/decoder.m"
60076       
60077 
60078             stmts = instantiate(pc,  "FISUBR.I16", DIS_MEM16);
60079 
60080       
60081 
60082       
60083       
60084       
60085     } 
60086     goto MATCH_finished_c; 
60087     
60088   MATCH_label_c1217: (void)0; /*placeholder for label*/ 
60089     { 
60090       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60091       nextPC = 3 + MATCH_p; 
60092       
60093 #line 1856 "frontend/machine/pentium/decoder.m"
60094       
60095 
60096             stmts = instantiate(pc,  "FIDIV.I16", DIS_MEM16);
60097 
60098       
60099 
60100       
60101       
60102       
60103     } 
60104     goto MATCH_finished_c; 
60105     
60106   MATCH_label_c1218: (void)0; /*placeholder for label*/ 
60107     { 
60108       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60109       nextPC = 7 + MATCH_p; 
60110       
60111 #line 1856 "frontend/machine/pentium/decoder.m"
60112       
60113 
60114             stmts = instantiate(pc,  "FIDIV.I16", DIS_MEM16);
60115 
60116       
60117 
60118       
60119       
60120       
60121     } 
60122     goto MATCH_finished_c; 
60123     
60124   MATCH_label_c1219: (void)0; /*placeholder for label*/ 
60125     { 
60126       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60127       nextPC = 6 + MATCH_p; 
60128       
60129 #line 1856 "frontend/machine/pentium/decoder.m"
60130       
60131 
60132             stmts = instantiate(pc,  "FIDIV.I16", DIS_MEM16);
60133 
60134       
60135 
60136       
60137       
60138       
60139     } 
60140     goto MATCH_finished_c; 
60141     
60142   MATCH_label_c1220: (void)0; /*placeholder for label*/ 
60143     { 
60144       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60145       nextPC = 3 + MATCH_p; 
60146       
60147 #line 1874 "frontend/machine/pentium/decoder.m"
60148       
60149 
60150             stmts = instantiate(pc,  "FIDIVR.I16", DIS_MEM16);
60151 
60152       
60153 
60154       
60155       
60156       
60157     } 
60158     goto MATCH_finished_c; 
60159     
60160   MATCH_label_c1221: (void)0; /*placeholder for label*/ 
60161     { 
60162       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60163       nextPC = 7 + MATCH_p; 
60164       
60165 #line 1874 "frontend/machine/pentium/decoder.m"
60166       
60167 
60168             stmts = instantiate(pc,  "FIDIVR.I16", DIS_MEM16);
60169 
60170       
60171 
60172       
60173       
60174       
60175     } 
60176     goto MATCH_finished_c; 
60177     
60178   MATCH_label_c1222: (void)0; /*placeholder for label*/ 
60179     { 
60180       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60181       nextPC = 6 + MATCH_p; 
60182       
60183 #line 1874 "frontend/machine/pentium/decoder.m"
60184       
60185 
60186             stmts = instantiate(pc,  "FIDIVR.I16", DIS_MEM16);
60187 
60188       
60189 
60190       
60191       
60192       
60193     } 
60194     goto MATCH_finished_c; 
60195     
60196   MATCH_label_c1223: (void)0; /*placeholder for label*/ 
60197     { 
60198       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60199       nextPC = 3 + MATCH_p; 
60200       
60201 #line 1883 "frontend/machine/pentium/decoder.m"
60202       
60203 
60204             stmts = instantiate(pc,  "FILD.lsI16", DIS_MEM16);
60205 
60206       
60207 
60208       
60209       
60210       
60211     } 
60212     goto MATCH_finished_c; 
60213     
60214   MATCH_label_c1224: (void)0; /*placeholder for label*/ 
60215     { 
60216       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60217       nextPC = 7 + MATCH_p; 
60218       
60219 #line 1883 "frontend/machine/pentium/decoder.m"
60220       
60221 
60222             stmts = instantiate(pc,  "FILD.lsI16", DIS_MEM16);
60223 
60224       
60225 
60226       
60227       
60228       
60229     } 
60230     goto MATCH_finished_c; 
60231     
60232   MATCH_label_c1225: (void)0; /*placeholder for label*/ 
60233     { 
60234       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60235       nextPC = 6 + MATCH_p; 
60236       
60237 #line 1883 "frontend/machine/pentium/decoder.m"
60238       
60239 
60240             stmts = instantiate(pc,  "FILD.lsI16", DIS_MEM16);
60241 
60242       
60243 
60244       
60245       
60246       
60247     } 
60248     goto MATCH_finished_c; 
60249     
60250   MATCH_label_c1226: (void)0; /*placeholder for label*/ 
60251     { 
60252       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60253       nextPC = 3 + MATCH_p; 
60254       
60255 #line 1895 "frontend/machine/pentium/decoder.m"
60256       
60257 
60258             stmts = instantiate(pc,  "FIST.lsI16", DIS_MEM16);
60259 
60260       
60261 
60262       
60263       
60264       
60265     } 
60266     goto MATCH_finished_c; 
60267     
60268   MATCH_label_c1227: (void)0; /*placeholder for label*/ 
60269     { 
60270       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60271       nextPC = 7 + MATCH_p; 
60272       
60273 #line 1895 "frontend/machine/pentium/decoder.m"
60274       
60275 
60276             stmts = instantiate(pc,  "FIST.lsI16", DIS_MEM16);
60277 
60278       
60279 
60280       
60281       
60282       
60283     } 
60284     goto MATCH_finished_c; 
60285     
60286   MATCH_label_c1228: (void)0; /*placeholder for label*/ 
60287     { 
60288       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60289       nextPC = 6 + MATCH_p; 
60290       
60291 #line 1895 "frontend/machine/pentium/decoder.m"
60292       
60293 
60294             stmts = instantiate(pc,  "FIST.lsI16", DIS_MEM16);
60295 
60296       
60297 
60298       
60299       
60300       
60301     } 
60302     goto MATCH_finished_c; 
60303     
60304   MATCH_label_c1229: (void)0; /*placeholder for label*/ 
60305     { 
60306       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60307       nextPC = 3 + MATCH_p; 
60308       
60309 #line 1901 "frontend/machine/pentium/decoder.m"
60310       
60311 
60312             stmts = instantiate(pc,  "FISTP.lsI16", DIS_MEM16);
60313 
60314       
60315 
60316       
60317       
60318       
60319     } 
60320     goto MATCH_finished_c; 
60321     
60322   MATCH_label_c1230: (void)0; /*placeholder for label*/ 
60323     { 
60324       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60325       nextPC = 7 + MATCH_p; 
60326       
60327 #line 1901 "frontend/machine/pentium/decoder.m"
60328       
60329 
60330             stmts = instantiate(pc,  "FISTP.lsI16", DIS_MEM16);
60331 
60332       
60333 
60334       
60335       
60336       
60337     } 
60338     goto MATCH_finished_c; 
60339     
60340   MATCH_label_c1231: (void)0; /*placeholder for label*/ 
60341     { 
60342       unsigned Mem16 = 1 + addressToPC(MATCH_p);
60343       nextPC = 6 + MATCH_p; 
60344       
60345 #line 1901 "frontend/machine/pentium/decoder.m"
60346       
60347 
60348             stmts = instantiate(pc,  "FISTP.lsI16", DIS_MEM16);
60349 
60350       
60351 
60352       
60353       
60354       
60355     } 
60356     goto MATCH_finished_c; 
60357     
60358   MATCH_label_c1232: (void)0; /*placeholder for label*/ 
60359     { 
60360       unsigned Mem80 = 1 + addressToPC(MATCH_p);
60361       nextPC = 3 + MATCH_p; 
60362       
60363 #line 1781 "frontend/machine/pentium/decoder.m"
60364       
60365 
60366             stmts = instantiate(pc,  "FBLD", DIS_MEM80);
60367 
60368       
60369 
60370       
60371       
60372       
60373     } 
60374     goto MATCH_finished_c; 
60375     
60376   MATCH_label_c1233: (void)0; /*placeholder for label*/ 
60377     { 
60378       unsigned Mem80 = 1 + addressToPC(MATCH_p);
60379       nextPC = 7 + MATCH_p; 
60380       
60381 #line 1781 "frontend/machine/pentium/decoder.m"
60382       
60383 
60384             stmts = instantiate(pc,  "FBLD", DIS_MEM80);
60385 
60386       
60387 
60388       
60389       
60390       
60391     } 
60392     goto MATCH_finished_c; 
60393     
60394   MATCH_label_c1234: (void)0; /*placeholder for label*/ 
60395     { 
60396       unsigned Mem80 = 1 + addressToPC(MATCH_p);
60397       nextPC = 6 + MATCH_p; 
60398       
60399 #line 1781 "frontend/machine/pentium/decoder.m"
60400       
60401 
60402             stmts = instantiate(pc,  "FBLD", DIS_MEM80);
60403 
60404       
60405 
60406       
60407       
60408       
60409     } 
60410     goto MATCH_finished_c; 
60411     
60412   MATCH_label_c1235: (void)0; /*placeholder for label*/ 
60413     { 
60414       unsigned Mem64 = 1 + addressToPC(MATCH_p);
60415       nextPC = 3 + MATCH_p; 
60416       
60417 #line 1889 "frontend/machine/pentium/decoder.m"
60418       
60419 
60420             stmts = instantiate(pc,  "FILD.lsI64", DIS_MEM64);
60421 
60422       
60423 
60424       
60425       
60426       
60427     } 
60428     goto MATCH_finished_c; 
60429     
60430   MATCH_label_c1236: (void)0; /*placeholder for label*/ 
60431     { 
60432       unsigned Mem64 = 1 + addressToPC(MATCH_p);
60433       nextPC = 7 + MATCH_p; 
60434       
60435 #line 1889 "frontend/machine/pentium/decoder.m"
60436       
60437 
60438             stmts = instantiate(pc,  "FILD.lsI64", DIS_MEM64);
60439 
60440       
60441 
60442       
60443       
60444       
60445     } 
60446     goto MATCH_finished_c; 
60447     
60448   MATCH_label_c1237: (void)0; /*placeholder for label*/ 
60449     { 
60450       unsigned Mem64 = 1 + addressToPC(MATCH_p);
60451       nextPC = 6 + MATCH_p; 
60452       
60453 #line 1889 "frontend/machine/pentium/decoder.m"
60454       
60455 
60456             stmts = instantiate(pc,  "FILD.lsI64", DIS_MEM64);
60457 
60458       
60459 
60460       
60461       
60462       
60463     } 
60464     goto MATCH_finished_c; 
60465     
60466   MATCH_label_c1238: (void)0; /*placeholder for label*/ 
60467     { 
60468       unsigned Mem80 = 1 + addressToPC(MATCH_p);
60469       nextPC = 3 + MATCH_p; 
60470       
60471 #line 1784 "frontend/machine/pentium/decoder.m"
60472       
60473 
60474             stmts = instantiate(pc,  "FBSTP", DIS_MEM80);
60475 
60476       
60477 
60478       
60479       
60480       
60481     } 
60482     goto MATCH_finished_c; 
60483     
60484   MATCH_label_c1239: (void)0; /*placeholder for label*/ 
60485     { 
60486       unsigned Mem80 = 1 + addressToPC(MATCH_p);
60487       nextPC = 7 + MATCH_p; 
60488       
60489 #line 1784 "frontend/machine/pentium/decoder.m"
60490       
60491 
60492             stmts = instantiate(pc,  "FBSTP", DIS_MEM80);
60493 
60494       
60495 
60496       
60497       
60498       
60499     } 
60500     goto MATCH_finished_c; 
60501     
60502   MATCH_label_c1240: (void)0; /*placeholder for label*/ 
60503     { 
60504       unsigned Mem80 = 1 + addressToPC(MATCH_p);
60505       nextPC = 6 + MATCH_p; 
60506       
60507 #line 1784 "frontend/machine/pentium/decoder.m"
60508       
60509 
60510             stmts = instantiate(pc,  "FBSTP", DIS_MEM80);
60511 
60512       
60513 
60514       
60515       
60516       
60517     } 
60518     goto MATCH_finished_c; 
60519     
60520   MATCH_label_c1241: (void)0; /*placeholder for label*/ 
60521     { 
60522       unsigned Mem64 = 1 + addressToPC(MATCH_p);
60523       nextPC = 3 + MATCH_p; 
60524       
60525 #line 1907 "frontend/machine/pentium/decoder.m"
60526       
60527 
60528             stmts = instantiate(pc,  "FISTP64", DIS_MEM64);
60529 
60530       
60531 
60532       
60533       
60534       
60535     } 
60536     goto MATCH_finished_c; 
60537     
60538   MATCH_label_c1242: (void)0; /*placeholder for label*/ 
60539     { 
60540       unsigned Mem64 = 1 + addressToPC(MATCH_p);
60541       nextPC = 7 + MATCH_p; 
60542       
60543 #line 1907 "frontend/machine/pentium/decoder.m"
60544       
60545 
60546             stmts = instantiate(pc,  "FISTP64", DIS_MEM64);
60547 
60548       
60549 
60550       
60551       
60552       
60553     } 
60554     goto MATCH_finished_c; 
60555     
60556   MATCH_label_c1243: (void)0; /*placeholder for label*/ 
60557     { 
60558       unsigned Mem64 = 1 + addressToPC(MATCH_p);
60559       nextPC = 6 + MATCH_p; 
60560       
60561 #line 1907 "frontend/machine/pentium/decoder.m"
60562       
60563 
60564             stmts = instantiate(pc,  "FISTP64", DIS_MEM64);
60565 
60566       
60567 
60568       
60569       
60570       
60571     } 
60572     goto MATCH_finished_c; 
60573     
60574   MATCH_label_c1244: (void)0; /*placeholder for label*/ 
60575     { 
60576       unsigned Eaddr = 1 + addressToPC(MATCH_p);
60577       nextPC = 2 + MATCH_p; 
60578       
60579 #line 1133 "frontend/machine/pentium/decoder.m"
60580       
60581 
60582             stmts = instantiate(pc,  "INC.Eb", DIS_EADDR8);
60583 
60584       
60585 
60586       //      | IN.eAX.DXod() =>
60587 
60588       //          stmts = instantiate(pc,  "IN.eAX.DXod");
60589 
60590       
60591 
60592       //      | IN.eAX.DXow() =>
60593 
60594       //          stmts = instantiate(pc,  "IN.eAX.DXow");
60595 
60596       
60597 
60598       //      | IN.AL.DX() =>
60599 
60600       //          stmts = instantiate(pc,  "IN.AL.DX");
60601 
60602       
60603 
60604       //      | IN.eAX.Ibod(i8) =>
60605 
60606       //          stmts = instantiate(pc,  "IN.eAX.Ibod", DIS_I8);
60607 
60608       
60609 
60610       //      | IN.eAX.Ibow(i8) =>
60611 
60612       //          stmts = instantiate(pc,  "IN.eAX.Ibow", DIS_I8);
60613 
60614       
60615 
60616       //      | IN.AL.Ib(i8) =>
60617 
60618       //          stmts = instantiate(pc,  "IN.AL.Ib", DIS_I8);
60619 
60620       
60621 
60622       
60623       
60624       
60625     } 
60626     goto MATCH_finished_c; 
60627     
60628   MATCH_label_c1245: (void)0; /*placeholder for label*/ 
60629     { 
60630       unsigned Eaddr = 1 + addressToPC(MATCH_p);
60631       nextPC = 3 + MATCH_p; 
60632       
60633 #line 1133 "frontend/machine/pentium/decoder.m"
60634       
60635 
60636             stmts = instantiate(pc,  "INC.Eb", DIS_EADDR8);
60637 
60638       
60639 
60640       //      | IN.eAX.DXod() =>
60641 
60642       //          stmts = instantiate(pc,  "IN.eAX.DXod");
60643 
60644       
60645 
60646       //      | IN.eAX.DXow() =>
60647 
60648       //          stmts = instantiate(pc,  "IN.eAX.DXow");
60649 
60650       
60651 
60652       //      | IN.AL.DX() =>
60653 
60654       //          stmts = instantiate(pc,  "IN.AL.DX");
60655 
60656       
60657 
60658       //      | IN.eAX.Ibod(i8) =>
60659 
60660       //          stmts = instantiate(pc,  "IN.eAX.Ibod", DIS_I8);
60661 
60662       
60663 
60664       //      | IN.eAX.Ibow(i8) =>
60665 
60666       //          stmts = instantiate(pc,  "IN.eAX.Ibow", DIS_I8);
60667 
60668       
60669 
60670       //      | IN.AL.Ib(i8) =>
60671 
60672       //          stmts = instantiate(pc,  "IN.AL.Ib", DIS_I8);
60673 
60674       
60675 
60676       
60677       
60678       
60679     } 
60680     goto MATCH_finished_c; 
60681     
60682   MATCH_label_c1246: (void)0; /*placeholder for label*/ 
60683     { 
60684       unsigned Eaddr = 1 + addressToPC(MATCH_p);
60685       nextPC = 7 + MATCH_p; 
60686       
60687 #line 1133 "frontend/machine/pentium/decoder.m"
60688       
60689 
60690             stmts = instantiate(pc,  "INC.Eb", DIS_EADDR8);
60691 
60692       
60693 
60694       //      | IN.eAX.DXod() =>
60695 
60696       //          stmts = instantiate(pc,  "IN.eAX.DXod");
60697 
60698       
60699 
60700       //      | IN.eAX.DXow() =>
60701 
60702       //          stmts = instantiate(pc,  "IN.eAX.DXow");
60703 
60704       
60705 
60706       //      | IN.AL.DX() =>
60707 
60708       //          stmts = instantiate(pc,  "IN.AL.DX");
60709 
60710       
60711 
60712       //      | IN.eAX.Ibod(i8) =>
60713 
60714       //          stmts = instantiate(pc,  "IN.eAX.Ibod", DIS_I8);
60715 
60716       
60717 
60718       //      | IN.eAX.Ibow(i8) =>
60719 
60720       //          stmts = instantiate(pc,  "IN.eAX.Ibow", DIS_I8);
60721 
60722       
60723 
60724       //      | IN.AL.Ib(i8) =>
60725 
60726       //          stmts = instantiate(pc,  "IN.AL.Ib", DIS_I8);
60727 
60728       
60729 
60730       
60731       
60732       
60733     } 
60734     goto MATCH_finished_c; 
60735     
60736   MATCH_label_c1247: (void)0; /*placeholder for label*/ 
60737     { 
60738       unsigned Eaddr = 1 + addressToPC(MATCH_p);
60739       nextPC = 6 + MATCH_p; 
60740       
60741 #line 1133 "frontend/machine/pentium/decoder.m"
60742       
60743 
60744             stmts = instantiate(pc,  "INC.Eb", DIS_EADDR8);
60745 
60746       
60747 
60748       //      | IN.eAX.DXod() =>
60749 
60750       //          stmts = instantiate(pc,  "IN.eAX.DXod");
60751 
60752       
60753 
60754       //      | IN.eAX.DXow() =>
60755 
60756       //          stmts = instantiate(pc,  "IN.eAX.DXow");
60757 
60758       
60759 
60760       //      | IN.AL.DX() =>
60761 
60762       //          stmts = instantiate(pc,  "IN.AL.DX");
60763 
60764       
60765 
60766       //      | IN.eAX.Ibod(i8) =>
60767 
60768       //          stmts = instantiate(pc,  "IN.eAX.Ibod", DIS_I8);
60769 
60770       
60771 
60772       //      | IN.eAX.Ibow(i8) =>
60773 
60774       //          stmts = instantiate(pc,  "IN.eAX.Ibow", DIS_I8);
60775 
60776       
60777 
60778       //      | IN.AL.Ib(i8) =>
60779 
60780       //          stmts = instantiate(pc,  "IN.AL.Ib", DIS_I8);
60781 
60782       
60783 
60784       
60785       
60786       
60787     } 
60788     goto MATCH_finished_c; 
60789     
60790   MATCH_label_c1248: (void)0; /*placeholder for label*/ 
60791     { 
60792       unsigned Eaddr = 1 + addressToPC(MATCH_p);
60793       nextPC = 2 + MATCH_p; 
60794       
60795 #line 1217 "frontend/machine/pentium/decoder.m"
60796       
60797 
60798             stmts = instantiate(pc,  "DEC.Eb", DIS_EADDR8);
60799 
60800       
60801 
60802       
60803       
60804       
60805     } 
60806     goto MATCH_finished_c; 
60807     
60808   MATCH_label_c1249: (void)0; /*placeholder for label*/ 
60809     { 
60810       unsigned Eaddr = 1 + addressToPC(MATCH_p);
60811       nextPC = 3 + MATCH_p; 
60812       
60813 #line 1217 "frontend/machine/pentium/decoder.m"
60814       
60815 
60816             stmts = instantiate(pc,  "DEC.Eb", DIS_EADDR8);
60817 
60818       
60819 
60820       
60821       
60822       
60823     } 
60824     goto MATCH_finished_c; 
60825     
60826   MATCH_label_c1250: (void)0; /*placeholder for label*/ 
60827     { 
60828       unsigned Eaddr = 1 + addressToPC(MATCH_p);
60829       nextPC = 7 + MATCH_p; 
60830       
60831 #line 1217 "frontend/machine/pentium/decoder.m"
60832       
60833 
60834             stmts = instantiate(pc,  "DEC.Eb", DIS_EADDR8);
60835 
60836       
60837 
60838       
60839       
60840       
60841     } 
60842     goto MATCH_finished_c; 
60843     
60844   MATCH_label_c1251: (void)0; /*placeholder for label*/ 
60845     { 
60846       unsigned Eaddr = 1 + addressToPC(MATCH_p);
60847       nextPC = 6 + MATCH_p; 
60848       
60849 #line 1217 "frontend/machine/pentium/decoder.m"
60850       
60851 
60852             stmts = instantiate(pc,  "DEC.Eb", DIS_EADDR8);
60853 
60854       
60855 
60856       
60857       
60858       
60859     } 
60860     goto MATCH_finished_c; 
60861     
60862   MATCH_label_c1252: (void)0; /*placeholder for label*/ 
60863     { 
60864       unsigned Eaddr = 1 + addressToPC(MATCH_p);
60865       nextPC = 2 + MATCH_p; 
60866       
60867 #line 1127 "frontend/machine/pentium/decoder.m"
60868       
60869 
60870             stmts = instantiate(pc,  "INC.Evod", DIS_EADDR32);
60871 
60872       
60873 
60874       
60875       
60876       
60877     } 
60878     goto MATCH_finished_c; 
60879     
60880   MATCH_label_c1253: (void)0; /*placeholder for label*/ 
60881     { 
60882       unsigned Eaddr = 1 + addressToPC(MATCH_p);
60883       nextPC = 3 + MATCH_p; 
60884       
60885 #line 1127 "frontend/machine/pentium/decoder.m"
60886       
60887 
60888             stmts = instantiate(pc,  "INC.Evod", DIS_EADDR32);
60889 
60890       
60891 
60892       
60893       
60894       
60895     } 
60896     goto MATCH_finished_c; 
60897     
60898   MATCH_label_c1254: (void)0; /*placeholder for label*/ 
60899     { 
60900       unsigned Eaddr = 1 + addressToPC(MATCH_p);
60901       nextPC = 7 + MATCH_p; 
60902       
60903 #line 1127 "frontend/machine/pentium/decoder.m"
60904       
60905 
60906             stmts = instantiate(pc,  "INC.Evod", DIS_EADDR32);
60907 
60908       
60909 
60910       
60911       
60912       
60913     } 
60914     goto MATCH_finished_c; 
60915     
60916   MATCH_label_c1255: (void)0; /*placeholder for label*/ 
60917     { 
60918       unsigned Eaddr = 1 + addressToPC(MATCH_p);
60919       nextPC = 6 + MATCH_p; 
60920       
60921 #line 1127 "frontend/machine/pentium/decoder.m"
60922       
60923 
60924             stmts = instantiate(pc,  "INC.Evod", DIS_EADDR32);
60925 
60926       
60927 
60928       
60929       
60930       
60931     } 
60932     goto MATCH_finished_c; 
60933     
60934   MATCH_label_c1256: (void)0; /*placeholder for label*/ 
60935     { 
60936       unsigned Eaddr = 1 + addressToPC(MATCH_p);
60937       nextPC = 2 + MATCH_p; 
60938       
60939 #line 1211 "frontend/machine/pentium/decoder.m"
60940       
60941 
60942             stmts = instantiate(pc,  "DEC.Evod", DIS_EADDR32);
60943 
60944       
60945 
60946       
60947       
60948       
60949     } 
60950     goto MATCH_finished_c; 
60951     
60952   MATCH_label_c1257: (void)0; /*placeholder for label*/ 
60953     { 
60954       unsigned Eaddr = 1 + addressToPC(MATCH_p);
60955       nextPC = 3 + MATCH_p; 
60956       
60957 #line 1211 "frontend/machine/pentium/decoder.m"
60958       
60959 
60960             stmts = instantiate(pc,  "DEC.Evod", DIS_EADDR32);
60961 
60962       
60963 
60964       
60965       
60966       
60967     } 
60968     goto MATCH_finished_c; 
60969     
60970   MATCH_label_c1258: (void)0; /*placeholder for label*/ 
60971     { 
60972       unsigned Eaddr = 1 + addressToPC(MATCH_p);
60973       nextPC = 7 + MATCH_p; 
60974       
60975 #line 1211 "frontend/machine/pentium/decoder.m"
60976       
60977 
60978             stmts = instantiate(pc,  "DEC.Evod", DIS_EADDR32);
60979 
60980       
60981 
60982       
60983       
60984       
60985     } 
60986     goto MATCH_finished_c; 
60987     
60988   MATCH_label_c1259: (void)0; /*placeholder for label*/ 
60989     { 
60990       unsigned Eaddr = 1 + addressToPC(MATCH_p);
60991       nextPC = 6 + MATCH_p; 
60992       
60993 #line 1211 "frontend/machine/pentium/decoder.m"
60994       
60995 
60996             stmts = instantiate(pc,  "DEC.Evod", DIS_EADDR32);
60997 
60998       
60999 
61000       
61001       
61002       
61003     } 
61004     goto MATCH_finished_c; 
61005     
61006   MATCH_label_c1260: (void)0; /*placeholder for label*/ 
61007     { 
61008       unsigned Eaddr = 1 + addressToPC(MATCH_p);
61009       nextPC = 2 + MATCH_p; 
61010       
61011 #line 115 "frontend/machine/pentium/decoder.m"
61012       
61013 
61014             /*
61015 
61016              * Register call
61017 
61018              */
61019 
61020             // Mike: there should probably be a HLNwayCall class for this!
61021 
61022             stmts = instantiate(pc,  "CALL.Evod", DIS_EADDR32);
61023 
61024             CallStatement* newCall = new CallStatement;
61025 
61026             // Record the fact that this is a computed call
61027 
61028             newCall->setIsComputed();
61029 
61030             // Set the destination expression
61031 
61032             newCall->setDest(DIS_EADDR32);
61033 
61034             result.rtl = new RTL(pc, stmts);
61035 
61036             result.rtl->appendStmt(newCall);
61037 
61038             // Only one instruction, so size of result is size of this decode
61039 
61040             //result.numBytes = nextPC - hostPC;
61041 
61042       
61043 
61044       
61045       
61046       
61047     } 
61048     goto MATCH_finished_c; 
61049     
61050   MATCH_label_c1261: (void)0; /*placeholder for label*/ 
61051     { 
61052       unsigned Eaddr = 1 + addressToPC(MATCH_p);
61053       nextPC = 3 + MATCH_p; 
61054       
61055 #line 115 "frontend/machine/pentium/decoder.m"
61056       
61057 
61058             /*
61059 
61060              * Register call
61061 
61062              */
61063 
61064             // Mike: there should probably be a HLNwayCall class for this!
61065 
61066             stmts = instantiate(pc,  "CALL.Evod", DIS_EADDR32);
61067 
61068             CallStatement* newCall = new CallStatement;
61069 
61070             // Record the fact that this is a computed call
61071 
61072             newCall->setIsComputed();
61073 
61074             // Set the destination expression
61075 
61076             newCall->setDest(DIS_EADDR32);
61077 
61078             result.rtl = new RTL(pc, stmts);
61079 
61080             result.rtl->appendStmt(newCall);
61081 
61082             // Only one instruction, so size of result is size of this decode
61083 
61084             //result.numBytes = nextPC - hostPC;
61085 
61086       
61087 
61088       
61089       
61090       
61091     } 
61092     goto MATCH_finished_c; 
61093     
61094   MATCH_label_c1262: (void)0; /*placeholder for label*/ 
61095     { 
61096       unsigned Eaddr = 1 + addressToPC(MATCH_p);
61097       nextPC = 7 + MATCH_p; 
61098       
61099 #line 115 "frontend/machine/pentium/decoder.m"
61100       
61101 
61102             /*
61103 
61104              * Register call
61105 
61106              */
61107 
61108             // Mike: there should probably be a HLNwayCall class for this!
61109 
61110             stmts = instantiate(pc,  "CALL.Evod", DIS_EADDR32);
61111 
61112             CallStatement* newCall = new CallStatement;
61113 
61114             // Record the fact that this is a computed call
61115 
61116             newCall->setIsComputed();
61117 
61118             // Set the destination expression
61119 
61120             newCall->setDest(DIS_EADDR32);
61121 
61122             result.rtl = new RTL(pc, stmts);
61123 
61124             result.rtl->appendStmt(newCall);
61125 
61126             // Only one instruction, so size of result is size of this decode
61127 
61128             //result.numBytes = nextPC - hostPC;
61129 
61130       
61131 
61132       
61133       
61134       
61135     } 
61136     goto MATCH_finished_c; 
61137     
61138   MATCH_label_c1263: (void)0; /*placeholder for label*/ 
61139     { 
61140       unsigned Eaddr = 1 + addressToPC(MATCH_p);
61141       nextPC = 6 + MATCH_p; 
61142       
61143 #line 115 "frontend/machine/pentium/decoder.m"
61144       
61145 
61146             /*
61147 
61148              * Register call
61149 
61150              */
61151 
61152             // Mike: there should probably be a HLNwayCall class for this!
61153 
61154             stmts = instantiate(pc,  "CALL.Evod", DIS_EADDR32);
61155 
61156             CallStatement* newCall = new CallStatement;
61157 
61158             // Record the fact that this is a computed call
61159 
61160             newCall->setIsComputed();
61161 
61162             // Set the destination expression
61163 
61164             newCall->setDest(DIS_EADDR32);
61165 
61166             result.rtl = new RTL(pc, stmts);
61167 
61168             result.rtl->appendStmt(newCall);
61169 
61170             // Only one instruction, so size of result is size of this decode
61171 
61172             //result.numBytes = nextPC - hostPC;
61173 
61174       
61175 
61176       
61177       
61178       
61179     } 
61180     goto MATCH_finished_c; 
61181     
61182   MATCH_label_c1264: (void)0; /*placeholder for label*/ 
61183     { 
61184       unsigned Eaddr = 1 + addressToPC(MATCH_p);
61185       nextPC = 2 + MATCH_p; 
61186       
61187 #line 131 "frontend/machine/pentium/decoder.m"
61188       
61189 
61190             /*
61191 
61192              * Register jump
61193 
61194              */
61195 
61196             CaseStatement* newJump = new CaseStatement;
61197 
61198             // Record the fact that this is a computed call
61199 
61200             newJump->setIsComputed();
61201 
61202             // Set the destination expression
61203 
61204             newJump->setDest(DIS_EADDR32);
61205 
61206             result.rtl = new RTL(pc, stmts);
61207 
61208             result.rtl->appendStmt(newJump);
61209 
61210             // Only one instruction, so size of result is size of this decode
61211 
61212             //result.numBytes = nextPC - hostPC;
61213 
61214         
61215 
61216         /*
61217 
61218          * Unconditional branches
61219 
61220          */
61221 
61222       
61223       
61224       
61225     } 
61226     goto MATCH_finished_c; 
61227     
61228   MATCH_label_c1265: (void)0; /*placeholder for label*/ 
61229     { 
61230       unsigned Eaddr = 1 + addressToPC(MATCH_p);
61231       nextPC = 3 + MATCH_p; 
61232       
61233 #line 131 "frontend/machine/pentium/decoder.m"
61234       
61235 
61236             /*
61237 
61238              * Register jump
61239 
61240              */
61241 
61242             CaseStatement* newJump = new CaseStatement;
61243 
61244             // Record the fact that this is a computed call
61245 
61246             newJump->setIsComputed();
61247 
61248             // Set the destination expression
61249 
61250             newJump->setDest(DIS_EADDR32);
61251 
61252             result.rtl = new RTL(pc, stmts);
61253 
61254             result.rtl->appendStmt(newJump);
61255 
61256             // Only one instruction, so size of result is size of this decode
61257 
61258             //result.numBytes = nextPC - hostPC;
61259 
61260         
61261 
61262         /*
61263 
61264          * Unconditional branches
61265 
61266          */
61267 
61268       
61269       
61270       
61271     } 
61272     goto MATCH_finished_c; 
61273     
61274   MATCH_label_c1266: (void)0; /*placeholder for label*/ 
61275     { 
61276       unsigned Eaddr = 1 + addressToPC(MATCH_p);
61277       nextPC = 7 + MATCH_p; 
61278       
61279 #line 131 "frontend/machine/pentium/decoder.m"
61280       
61281 
61282             /*
61283 
61284              * Register jump
61285 
61286              */
61287 
61288             CaseStatement* newJump = new CaseStatement;
61289 
61290             // Record the fact that this is a computed call
61291 
61292             newJump->setIsComputed();
61293 
61294             // Set the destination expression
61295 
61296             newJump->setDest(DIS_EADDR32);
61297 
61298             result.rtl = new RTL(pc, stmts);
61299 
61300             result.rtl->appendStmt(newJump);
61301 
61302             // Only one instruction, so size of result is size of this decode
61303 
61304             //result.numBytes = nextPC - hostPC;
61305 
61306         
61307 
61308         /*
61309 
61310          * Unconditional branches
61311 
61312          */
61313 
61314       
61315       
61316       
61317     } 
61318     goto MATCH_finished_c; 
61319     
61320   MATCH_label_c1267: (void)0; /*placeholder for label*/ 
61321     { 
61322       unsigned Eaddr = 1 + addressToPC(MATCH_p);
61323       nextPC = 6 + MATCH_p; 
61324       
61325 #line 131 "frontend/machine/pentium/decoder.m"
61326       
61327 
61328             /*
61329 
61330              * Register jump
61331 
61332              */
61333 
61334             CaseStatement* newJump = new CaseStatement;
61335 
61336             // Record the fact that this is a computed call
61337 
61338             newJump->setIsComputed();
61339 
61340             // Set the destination expression
61341 
61342             newJump->setDest(DIS_EADDR32);
61343 
61344             result.rtl = new RTL(pc, stmts);
61345 
61346             result.rtl->appendStmt(newJump);
61347 
61348             // Only one instruction, so size of result is size of this decode
61349 
61350             //result.numBytes = nextPC - hostPC;
61351 
61352         
61353 
61354         /*
61355 
61356          * Unconditional branches
61357 
61358          */
61359 
61360       
61361       
61362       
61363     } 
61364     goto MATCH_finished_c; 
61365     
61366   MATCH_label_c1268: (void)0; /*placeholder for label*/ 
61367     { 
61368       unsigned Eaddr = 1 + addressToPC(MATCH_p);
61369       nextPC = 2 + MATCH_p; 
61370       
61371 #line 838 "frontend/machine/pentium/decoder.m"
61372       
61373 
61374             stmts = instantiate(pc,  "PUSH.Evod", DIS_EADDR32);
61375 
61376       
61377 
61378       
61379       
61380       
61381     } 
61382     goto MATCH_finished_c; 
61383     
61384   MATCH_label_c1269: (void)0; /*placeholder for label*/ 
61385     { 
61386       unsigned Eaddr = 1 + addressToPC(MATCH_p);
61387       nextPC = 3 + MATCH_p; 
61388       
61389 #line 838 "frontend/machine/pentium/decoder.m"
61390       
61391 
61392             stmts = instantiate(pc,  "PUSH.Evod", DIS_EADDR32);
61393 
61394       
61395 
61396       
61397       
61398       
61399     } 
61400     goto MATCH_finished_c; 
61401     
61402   MATCH_label_c1270: (void)0; /*placeholder for label*/ 
61403     { 
61404       unsigned Eaddr = 1 + addressToPC(MATCH_p);
61405       nextPC = 7 + MATCH_p; 
61406       
61407 #line 838 "frontend/machine/pentium/decoder.m"
61408       
61409 
61410             stmts = instantiate(pc,  "PUSH.Evod", DIS_EADDR32);
61411 
61412       
61413 
61414       
61415       
61416       
61417     } 
61418     goto MATCH_finished_c; 
61419     
61420   MATCH_label_c1271: (void)0; /*placeholder for label*/ 
61421     { 
61422       unsigned Eaddr = 1 + addressToPC(MATCH_p);
61423       nextPC = 6 + MATCH_p; 
61424       
61425 #line 838 "frontend/machine/pentium/decoder.m"
61426       
61427 
61428             stmts = instantiate(pc,  "PUSH.Evod", DIS_EADDR32);
61429 
61430       
61431 
61432       
61433       
61434       
61435     } 
61436     goto MATCH_finished_c; 
61437     
61438   MATCH_finished_c: (void)0; /*placeholder for label*/
61439   
61440 }
61441 
61442 #line 2125 "frontend/machine/pentium/decoder.m"
61443 
61444     if (result.rtl == 0)
61445         result.rtl = new RTL(pc, stmts);
61446     result.numBytes = nextPC - hostPC;
61447     return result;
61448 }
61449 
61450 /*==============================================================================
61451  * These are machine specific functions used to decode instruction operands into Exp*s.
61452  *============================================================================*/
61453 
61454 /*==============================================================================
61455  * FUNCTION:        dis_Mem
61456  * OVERVIEW:        Converts a dynamic address to a Exp* expression.
61457  *                  E.g. [1000] --> m[, 1000
61458  * PARAMETERS:      pc - the address of the Eaddr part of the instr
61459  *                  expr - the expression that will be built
61460  * RETURNS:         the Exp* representation of the given Eaddr
61461  *============================================================================*/
61462 Exp* PentiumDecoder::dis_Mem(ADDRESS pc)
61463 {
61464     Exp* expr = NULL;
61465     lastDwordLc = (unsigned)-1;
61466 
61467 
61468 
61469 #line 2148 "frontend/machine/pentium/decoder.m"
61470 { 
61471   dword MATCH_p = 
61472     
61473 #line 2148 "frontend/machine/pentium/decoder.m"
61474     pc
61475     ;
61476   unsigned /* [0..255] */ MATCH_w_8_0;
61477   unsigned /* [0..255] */ MATCH_w_8_8;
61478   unsigned MATCH_w_32_8;
61479   unsigned /* [0..255] */ MATCH_w_8_16;
61480   unsigned MATCH_w_32_16;
61481   { 
61482     MATCH_w_8_0 = getByte(MATCH_p); 
61483     
61484       switch((MATCH_w_8_0 >> 6 & 0x3) /* mod at 0 */) {
61485         case 0: 
61486           
61487             switch((MATCH_w_8_0 & 0x7) /* r_m at 0 */) {
61488               case 0: case 1: case 2: case 3: case 6: case 7: 
61489                 { 
61490                   unsigned base = (MATCH_w_8_0 & 0x7) /* r_m at 0 */;
61491                   
61492 #line 2203 "frontend/machine/pentium/decoder.m"
61493                    
61494 
61495                             // m[ r[base] ]
61496 
61497                             expr = Location::memOf(dis_Reg(24+base));
61498 
61499                   
61500                   
61501                   
61502                 }
61503                 
61504                 break;
61505               case 4: 
61506                 MATCH_w_8_8 = getByte(1 + MATCH_p); 
61507                 if ((MATCH_w_8_8 & 0x7) /* base at 8 */ == 5) 
61508                   if ((MATCH_w_8_8 >> 3 & 0x7) /* index at 8 */ == 4) { 
61509                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
61510                     { 
61511                       unsigned d = MATCH_w_32_16 /* i32 at 16 */;
61512                       
61513 #line 2213 "frontend/machine/pentium/decoder.m"
61514                       
61515 
61516                                 // [d] (Same as Abs32 using SIB)
61517 
61518                                 expr = Location::memOf(addReloc(new Const(d)));
61519 
61520                       
61521                       
61522                       
61523                     }
61524                     
61525                   } /*opt-block*/
61526                   else { 
61527                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
61528                     { 
61529                       unsigned d = MATCH_w_32_16 /* i32 at 16 */;
61530                       unsigned index = 
61531                         (MATCH_w_8_8 >> 3 & 0x7) /* index at 8 */;
61532                       unsigned ss = (MATCH_w_8_8 >> 6 & 0x3) /* ss at 8 */;
61533                       
61534 #line 2206 "frontend/machine/pentium/decoder.m"
61535                       
61536 
61537                                 // m[ r[index] * ss + d ]
61538 
61539                                 expr = Location::memOf(new Binary(opPlus,
61540 
61541                                         new Binary(opMult,
61542 
61543                                             dis_Reg(24+index),
61544 
61545                                             new Const(1<<ss)),
61546 
61547                                         addReloc(new Const(d))));
61548 
61549                       
61550                       
61551                       
61552                     }
61553                     
61554                   } /*opt-block*/ /*opt-block+*/
61555                 else 
61556                   if ((MATCH_w_8_8 >> 3 & 0x7) /* index at 8 */ == 4) { 
61557                     unsigned base = (MATCH_w_8_8 & 0x7) /* base at 8 */;
61558                     
61559 #line 2170 "frontend/machine/pentium/decoder.m"
61560                     
61561 
61562                                 // m[ r[base] ]
61563 
61564                                 expr = Location::memOf(dis_Reg(24+base));
61565 
61566                     
61567                     
61568                     
61569                   } /*opt-block*//*opt-block+*/
61570                   else { 
61571                     unsigned base = (MATCH_w_8_8 & 0x7) /* base at 8 */;
61572                     unsigned index = 
61573                       (MATCH_w_8_8 >> 3 & 0x7) /* index at 8 */;
61574                     unsigned ss = (MATCH_w_8_8 >> 6 & 0x3) /* ss at 8 */;
61575                     
61576 #line 2163 "frontend/machine/pentium/decoder.m"
61577                     
61578 
61579                                 // m[ r[base] + r[index] * ss]
61580 
61581                                 expr = Location::memOf(new Binary(opPlus,
61582 
61583                                         dis_Reg(24+base),
61584 
61585                                         new Binary(opMult,
61586 
61587                                             dis_Reg(24+index),
61588 
61589                                             new Const(1<<ss))));
61590 
61591                     
61592                     
61593                     
61594                   } /*opt-block*//*opt-block+*/ /*opt-block+*/
61595                 
61596                 break;
61597               case 5: 
61598                 MATCH_w_32_8 = getDword(1 + MATCH_p); 
61599                 { 
61600                   unsigned a = MATCH_w_32_8 /* i32 at 8 */;
61601                   
61602 #line 2150 "frontend/machine/pentium/decoder.m"
61603                   
61604 
61605                             // [a]
61606 
61607                             expr = Location::memOf(addReloc(new Const(a)));
61608 
61609                   
61610                   
61611                   
61612                 }
61613                 
61614                 break;
61615               default: assert(0);
61616             } /* (MATCH_w_8_0 & 0x7) -- r_m at 0 --*/ 
61617           break;
61618         case 1: 
61619           if ((MATCH_w_8_0 & 0x7) /* r_m at 0 */ == 4) { 
61620             MATCH_w_8_8 = getByte(1 + MATCH_p); 
61621             if ((MATCH_w_8_8 >> 3 & 0x7) /* index at 8 */ == 4) { 
61622               MATCH_w_8_16 = getByte(2 + MATCH_p); 
61623               { 
61624                 unsigned base = (MATCH_w_8_8 & 0x7) /* base at 8 */;
61625                 unsigned d = (MATCH_w_8_16 & 0xff) /* i8 at 16 */;
61626                 
61627 #line 2196 "frontend/machine/pentium/decoder.m"
61628                 
61629 
61630                             // m[ r[ base] + d ]
61631 
61632                             // Note: d should be sign extended; we do it here manually
61633 
61634                             signed char ds8 = d;
61635 
61636                             expr = Location::memOf(new Binary(opPlus,
61637 
61638                                     dis_Reg(24+base),
61639 
61640                                     new Const(ds8)));
61641 
61642                 
61643                 
61644                 
61645               }
61646               
61647             } /*opt-block*/
61648             else { 
61649               MATCH_w_8_16 = getByte(2 + MATCH_p); 
61650               { 
61651                 unsigned base = (MATCH_w_8_8 & 0x7) /* base at 8 */;
61652                 int /* [~128..127] */ d = 
61653                   sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
61654                 unsigned index = (MATCH_w_8_8 >> 3 & 0x7) /* index at 8 */;
61655                 unsigned ss = (MATCH_w_8_8 >> 6 & 0x3) /* ss at 8 */;
61656                 
61657 #line 2187 "frontend/machine/pentium/decoder.m"
61658                 
61659 
61660                             // m[ r[ base ] + r[ index ] * ss + d ]
61661 
61662                             expr = Location::memOf(new Binary(opPlus,
61663 
61664                                     dis_Reg(24+base),
61665 
61666                                     new Binary(opPlus,
61667 
61668                                         new Binary(opMult,
61669 
61670                                             dis_Reg(24+index),
61671 
61672                                             new Const(1<<ss)),
61673 
61674                                         addReloc(new Const(d)))));
61675 
61676                 
61677                 
61678                 
61679               }
61680               
61681             } /*opt-block*/
61682             
61683           } /*opt-block*/
61684           else { 
61685             MATCH_w_8_8 = getByte(1 + MATCH_p); 
61686             { 
61687               int /* [~128..127] */ d = 
61688                 sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
61689               unsigned r32 = (MATCH_w_8_0 & 0x7) /* r_m at 0 */;
61690               
61691 #line 2158 "frontend/machine/pentium/decoder.m"
61692                
61693 
61694                         // m[ r[ r32] + d]
61695 
61696                         expr = Location::memOf(new Binary(opPlus,
61697 
61698                                 dis_Reg(24+r32),
61699 
61700                                 addReloc(new Const(d))));
61701 
61702               
61703               
61704               
61705             }
61706             
61707           } /*opt-block*/
61708           break;
61709         case 2: 
61710           if ((MATCH_w_8_0 & 0x7) /* r_m at 0 */ == 4) { 
61711             MATCH_w_8_8 = getByte(1 + MATCH_p); 
61712             if ((MATCH_w_8_8 >> 3 & 0x7) /* index at 8 */ == 4) { 
61713               MATCH_w_32_16 = getDword(2 + MATCH_p); 
61714               { 
61715                 unsigned base = (MATCH_w_8_8 & 0x7) /* base at 8 */;
61716                 unsigned d = MATCH_w_32_16 /* i32 at 16 */;
61717                 
61718 #line 2182 "frontend/machine/pentium/decoder.m"
61719                 
61720 
61721                             // m[ r[ base] + d ]
61722 
61723                             expr = Location::memOf(new Binary(opPlus,
61724 
61725                                     dis_Reg(24+base),
61726 
61727                                     addReloc(new Const(d))));
61728 
61729                 
61730                 
61731                 
61732               }
61733               
61734             } /*opt-block*/
61735             else { 
61736               MATCH_w_32_16 = getDword(2 + MATCH_p); 
61737               { 
61738                 unsigned base = (MATCH_w_8_8 & 0x7) /* base at 8 */;
61739                 unsigned d = MATCH_w_32_16 /* i32 at 16 */;
61740                 unsigned index = (MATCH_w_8_8 >> 3 & 0x7) /* index at 8 */;
61741                 unsigned ss = (MATCH_w_8_8 >> 6 & 0x3) /* ss at 8 */;
61742                 
61743 #line 2173 "frontend/machine/pentium/decoder.m"
61744                 
61745 
61746                             // m[ r[ base ] + r[ index ] * ss + d ]
61747 
61748                             expr = Location::memOf(new Binary(opPlus,
61749 
61750                                     dis_Reg(24+base),
61751 
61752                                     new Binary(opPlus,
61753 
61754                                         new Binary(opMult,
61755 
61756                                             dis_Reg(24+index),
61757 
61758                                             new Const(1<<ss)),
61759 
61760                                         addReloc(new Const(d)))));
61761 
61762                 
61763                 
61764                 
61765               }
61766               
61767             } /*opt-block*/
61768             
61769           } /*opt-block*/
61770           else { 
61771             MATCH_w_32_8 = getDword(1 + MATCH_p); 
61772             { 
61773               unsigned base = (MATCH_w_8_0 & 0x7) /* r_m at 0 */;
61774               unsigned d = MATCH_w_32_8 /* i32 at 8 */;
61775               
61776 #line 2153 "frontend/machine/pentium/decoder.m"
61777                
61778 
61779                         // m[ r[ base] + d]
61780 
61781                         expr = Location::memOf(new Binary(opPlus,
61782 
61783                                 dis_Reg(24+base),
61784 
61785                                 addReloc(new Const(d))));
61786 
61787               
61788               
61789               
61790             }
61791             
61792           } /*opt-block*/
61793           break;
61794         case 3: 
61795           assert(0);  /* no match */break;
61796         default: assert(0);
61797       } /* (MATCH_w_8_0 >> 6 & 0x3) -- mod at 0 --*/ 
61798     
61799   }goto MATCH_finished_b; 
61800   
61801   MATCH_finished_b: (void)0; /*placeholder for label*/
61802   
61803 }
61804 
61805 #line 2217 "frontend/machine/pentium/decoder.m"
61806     return expr;
61807 }
61808 
61809 /*==============================================================================
61810  * FUNCTION:        dis_Eaddr
61811  * OVERVIEW:        Converts a dynamic address to a Exp* expression.
61812  *                  E.g. %ecx --> r[ 25 ]
61813  * CALLED FROM:     Macros DIS_EADDR32, DIS_EADDR16 and DIS_EADDR8
61814  * PARAMETERS:      pc - the instruction stream address of the dynamic
61815  *                    address
61816  *                  size - size of the operand (important if a register)
61817  * RETURNS:         the Exp* representation of the given Eaddr
61818  *============================================================================*/
61819 Exp* PentiumDecoder::dis_Eaddr(ADDRESS pc, int size)
61820 {
61821 
61822 
61823 #line 2231 "frontend/machine/pentium/decoder.m"
61824 { 
61825   dword MATCH_p = 
61826     
61827 #line 2231 "frontend/machine/pentium/decoder.m"
61828     pc
61829     ;
61830   unsigned /* [0..255] */ MATCH_w_8_0;
61831   unsigned /* [0..255] */ MATCH_w_8_8;
61832   { 
61833     MATCH_w_8_0 = getByte(MATCH_p); 
61834     if ((MATCH_w_8_0 >> 6 & 0x3) /* mod at 0 */ == 3) { 
61835       unsigned reg = (MATCH_w_8_0 & 0x7) /* r_m at 0 */;
61836       
61837 #line 2235 "frontend/machine/pentium/decoder.m"
61838       
61839 
61840             Exp* e;
61841 
61842             switch(size) {
61843 
61844                 case  8: e = dis_Reg(8+reg); break;
61845 
61846                 case 16: e = dis_Reg(0+reg); break;
61847 
61848                 default:
61849 
61850                 case 32: e = dis_Reg(24+reg); break;
61851 
61852             }
61853 
61854             return e;
61855 
61856       
61857       
61858       
61859     } /*opt-block*//*opt-block+*/
61860     else 
61861       goto MATCH_label_a0;  /*opt-block+*/
61862     
61863   }goto MATCH_finished_a; 
61864   
61865   MATCH_label_a0: (void)0; /*placeholder for label*/ 
61866     { 
61867       unsigned mem = addressToPC(MATCH_p);
61868       
61869 #line 2232 "frontend/machine/pentium/decoder.m"
61870       
61871 
61872             return dis_Mem (mem);
61873 
61874       
61875       
61876       
61877     } 
61878     goto MATCH_finished_a; 
61879     
61880   MATCH_finished_a: (void)0; /*placeholder for label*/
61881   
61882 }
61883 
61884 #line 2245 "frontend/machine/pentium/decoder.m"
61885 }
61886 
61887 /*==============================================================================
61888  * FUNCTION:      isFuncPrologue()
61889  * OVERVIEW:      Check to see if the instructions at the given offset match
61890  *                  any callee prologue, i.e. does it look like this offset
61891  *                  is a pointer to a function?
61892  * PARAMETERS:    hostPC - pointer to the code in question (native address)
61893  * RETURNS:       True if a match found
61894  *============================================================================*/
61895 bool PentiumDecoder::isFuncPrologue(ADDRESS hostPC)
61896 {
61897 #if 0
61898     int locals, regs;
61899     if ((InstructionPatterns::frameless_pro(prog.csrSrc, hostPC, locals, regs))
61900         != NULL)
61901             return true;
61902     if ((InstructionPatterns::struct_ptr(prog.csrSrc, hostPC, locals, regs))
61903         != NULL)
61904             return true;
61905     if ((InstructionPatterns::std_entry(prog.csrSrc, hostPC, locals, regs))
61906         != NULL)
61907             return true;
61908 #endif
61909     return false;
61910 }
61911 
61912 
61913 /**********************************
61914  * These are the fetch routines.
61915  **********************************/   
61916 
61917 /*==============================================================================
61918  * FUNCTION:        getWord
61919  * OVERVIEW:        Returns the word starting at the given address.
61920  * PARAMETERS:      lc - address at which to decode the double
61921  * RETURNS:         the decoded double
61922  *============================================================================*/
61923 Byte PentiumDecoder::getByte (unsigned lc)
61924 /* getByte - returns next byte from image pointed to by lc.  */
61925 {
61926     return *(Byte *)lc;
61927 }
61928 
61929 /*==============================================================================
61930  * FUNCTION:        getWord
61931  * OVERVIEW:        Returns the word starting at the given address.
61932  * PARAMETERS:      lc - address at which to decode the double
61933  * RETURNS:         the decoded double
61934  *============================================================================*/
61935 SWord PentiumDecoder::getWord (unsigned lc)
61936 /* get2Bytes - returns next 2-Byte from image pointed to by lc.  */
61937 {
61938     return (SWord)(*(Byte *)lc + (*(Byte *)(lc+1) << 8));
61939 }
61940 
61941 /*==============================================================================
61942  * FUNCTION:        getDword
61943  * OVERVIEW:        Returns the double starting at the given address.
61944  * PARAMETERS:      lc - address at which to decode the double
61945  * RETURNS:         the decoded double
61946  *============================================================================*/
61947 DWord PentiumDecoder::getDword (unsigned lc)
61948 /* get4Bytes - returns the next 4-Byte word from image pointed to by lc. */
61949 {
61950     lastDwordLc = lc - prog->getTextDelta();
61951     return (DWord)(*(Byte *)lc + (*(Byte *)(lc+1) << 8) + (*(Byte *)(lc+2) << 16) + (*(Byte *)(lc+3) << 24));
61952 }
61953 
61954 
61955 /*==============================================================================
61956  * FUNCTION:       PentiumDecoder::PentiumDecoder
61957  * OVERVIEW:       Constructor. The code won't work without this (not sure why the default constructor won't do...)
61958  * PARAMETERS:     None
61959  * RETURNS:        N/A
61960  *============================================================================*/
61961 PentiumDecoder::PentiumDecoder(Prog* prog) : NJMCDecoder(prog)
61962 {
61963     std::string file = Boomerang::get()->getProgPath() + "frontend/machine/pentium/pentium.ssl";
61964     RTLDict.readSSLFile(file.c_str());
61965 }
61966 
61967 // For now...
61968 int PentiumDecoder::decodeAssemblyInstruction(unsigned, int)
61969 { return 0; }
61970 
61971 /*==============================================================================
61972  * FUNCTION:       genBSFR
61973  * OVERVIEW:       Generate statements for the BSF and BSR series (Bit Scan Forward/Reverse)
61974  * PARAMETERS:     pc: native PC address (start of the BSF/BSR instruction)
61975  *                 reg: an expression for the destination register
61976  *                 modrm: an expression for the operand being scanned
61977  *                 init: initial value for the dest register
61978  *                 size: sizeof(modrm) (in bits)
61979  *                 incdec: either opPlus for Forward scans, or opMinus for Reverse scans
61980  *                 numBytes: number of bytes this instruction
61981  * RETURNS:        true if have to exit early (not in last state)
61982  *============================================================================*/
61983 static int BSFRstate = 0;       // State number for this state machine
61984 void genBSFR(ADDRESS pc, Exp* dest, Exp* modrm, int init, int size,
61985   OPER incdec, int numBytes) {
61986     // Note the horrible hack needed here. We need initialisation code, and an extra branch, so the %SKIP/%RPT won't
61987     // work. We need to emit 6 statements, but these need to be in 3 RTLs, since the destination of a branch has to be
61988     // to the start of an RTL.  So we use a state machine, and set numBytes to 0 for the first two times. That way, this
61989     // instruction ends up emitting three RTLs, each with the semantics we need.
61990     // Note: we don't use pentium.SSL for these.
61991     // BSFR1:
61992     //  pc+0:   zf := 1
61993     //  pc+0:   branch exit condition modrm = 0
61994     // BSFR2:
61995     //  pc+1:   zf := 0
61996     //  pc+1:   dest := init
61997     // BSFR3:
61998     //  pc+2: dest := dest op 1
61999     //  pc+2: branch pc+2 condition modrm@[dest:dest]=0
62000     // exit:
62001 
62002     std::list<Statement*>* stmts = new std::list<Statement*>;
62003     Statement* s;
62004     BranchStatement* b;
62005     switch (BSFRstate) {
62006         case 0:
62007             s = new Assign(
62008                 new IntegerType(1),
62009                 new Terminal(opZF),
62010                 new Const(1));
62011             stmts->push_back(s);
62012             b = new BranchStatement;
62013             b->setDest(pc+numBytes);
62014             b->setCondType(BRANCH_JE);
62015             b->setCondExpr(
62016                 new Binary(opEquals,
62017                     modrm->clone(),
62018                     new Const(0)));
62019             stmts->push_back(b);
62020             break;
62021         case 1:
62022             s = new Assign(
62023                 new IntegerType(1),
62024                 new Terminal(opZF),
62025                 new Const(0));
62026             stmts->push_back(s);
62027             s = new Assign(
62028                 new IntegerType(size),
62029                 dest->clone(),
62030                 new Const(init));
62031             stmts->push_back(s);
62032             break;
62033         case 2:
62034             s = new Assign(
62035                 new IntegerType(size),
62036                 dest->clone(),
62037                 new Binary(incdec,
62038                     dest->clone(),
62039                     new Const(1)));
62040             stmts->push_back(s);
62041             b = new BranchStatement;
62042             b->setDest(pc+2);
62043             b->setCondType(BRANCH_JE);
62044             b->setCondExpr(
62045                 new Binary(opEquals,
62046                     new Ternary(opAt,
62047                         modrm->clone(),
62048                         dest->clone(),
62049                         dest->clone()),
62050                     new Const(0)));
62051             stmts->push_back(b);
62052             break;
62053         default:
62054             // Should never happen
62055             assert(BSFRstate - BSFRstate);
62056     }
62057     result.rtl = new RTL(pc + BSFRstate, stmts);
62058     // Keep numBytes == 0 until the last state, so we re-decode this instruction 3 times
62059     if (BSFRstate != 3-1) {
62060         // Let the number of bytes be 1. This is important at least for setting the fallthrough address for the branch
62061         // (in the first RTL), which should point to the next RTL
62062         result.numBytes = 1;
62063         result.reDecode = true;     // Decode this instuction again
62064     } else {
62065         result.numBytes = numBytes;
62066         result.reDecode = false;
62067     }
62068     if (DEBUG_DECODER)
62069         std::cout << std::hex << pc+BSFRstate << std::dec << ": " <<
62070         "BS" << (init == -1 ? "F" : "R") << (size==32 ? ".od" : ".ow") <<
62071         BSFRstate+1 << "\n";
62072     if (++BSFRstate == 3)
62073         BSFRstate = 0;      // Ready for next time
62074         
62075 }
62076 
62077 
62078 Exp *PentiumDecoder::addReloc(Exp *e)
62079 {
62080     if (lastDwordLc != (unsigned)-1)
62081         e = prog->addReloc(e, lastDwordLc);
62082     return e;
62083 }
62084 
62085 
62086