pentium/disassembler.cpp

Go to the documentation of this file.
00001 #define sign_extend(N,SIZE) (((int)((N) << (sizeof(unsigned)*8-(SIZE)))) >> (sizeof(unsigned)*8-(SIZE)))
00002 #include <assert.h>
00003 
00004 #line 2 "machine/pentium/disassembler.m"
00005 /*
00006  * Copyright (C) 2002, Sun Microsystems, Inc
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:       disassembler.m
00016  * OVERVIEW:   disassembler skeleton file for x86 SLED specification
00017  *
00018  * Created: 7 Jan 02 - Cristina, based on machine/pentium/decoder_low.m and 
00019  *             machine/sparc/disassembler.m
00020  *============================================================================*/
00021 
00022 
00023 #include "global.h"
00024 #include "decoder.h"
00025 
00026 
00027 /*==============================================================================
00028  * FUNCTION:       NJMCDecoder::decodeAssemblyInstruction
00029  * OVERVIEW:       Decodes a machine instruction and displays its assembly
00030  *                 representation onto the external array _assembly[].
00031  * PARAMETERS:     pc - the native address of the pc
00032  *                 delta - the difference between the native address and
00033  *                  the host address of the pc
00034  * RETURNS:        number of bytes taken up by the decoded instruction
00035  *                  (i.e. number of bytes processed)
00036  *============================================================================*/
00037 int NJMCDecoder::decodeAssemblyInstruction (ADDRESS pc, int delta)
00038 {
00039     ADDRESS hostPC = pc + delta; 
00040     ADDRESS nextPC; 
00041 
00042     sprintf(_assembly, "%X: %08X  ", pc, getDword(hostPC) );
00043     char* str = _assembly + strlen(_assembly);
00044 
00045 
00046 
00047 #line 41 "machine/pentium/disassembler.m"
00048 { 
00049   dword MATCH_p = 
00050     
00051     #line 41 "machine/pentium/disassembler.m"
00052     hostPC
00053     ;
00054   char *MATCH_name;
00055   static char *MATCH_name_page_0[] = {"SEG.FS", "CALL.Jvod", };
00056   static char *MATCH_name_page_6[] = {"REPNE.MOVSvow", "REPNE.STOSvow", };
00057   static char *MATCH_name_page_7[] = {"REPNE.CMPSvow", "REPNE.LODSvow", };
00058   static char *MATCH_name_page_8[] = {"REP.MOVSvow", "REPNE.SCASvow", };
00059   static char *MATCH_name_page_9[] = {"REPNE.MOVSB", "REPNE.STOSB", };
00060   static char *MATCH_name_page_10[] = {"REPNE.MOVSvod", "REPNE.STOSvod", };
00061   static char *MATCH_name_page_11[] = {"REPNE.CMPSB", "REPNE.LODSB", };
00062   static char *MATCH_name_page_12[] = {"REPNE.CMPSvod", "REPNE.LODSvod", };
00063   static char *MATCH_name_page_13[] = {"REP.MOVSB", "REPNE.SCASB", };
00064   static char *MATCH_name_page_14[] = {"REP.MOVSvod", "REPNE.SCASvod", };
00065   static char *MATCH_name_page_15[] = {"REP.CMPSvow", "REP.STOSvow", };
00066   static char *MATCH_name_page_18[] = {"REP.CMPSB", "REP.STOSB", };
00067   static char *MATCH_name_page_19[] = {"REP.CMPSvod", "REP.STOSvod", };
00068   unsigned /* [0..255] */ MATCH_w_8_0;
00069   unsigned /* [0..255] */ MATCH_w_8_8;
00070   unsigned /* [0..65535] */ MATCH_w_16_8;
00071   unsigned MATCH_w_32_8;
00072   unsigned /* [0..255] */ MATCH_w_8_16;
00073   unsigned /* [0..65535] */ MATCH_w_16_16;
00074   unsigned MATCH_w_32_16;
00075   unsigned /* [0..255] */ MATCH_w_8_24;
00076   unsigned /* [0..65535] */ MATCH_w_16_24;
00077   unsigned MATCH_w_32_24;
00078   unsigned /* [0..255] */ MATCH_w_8_32;
00079   unsigned /* [0..65535] */ MATCH_w_16_32;
00080   unsigned MATCH_w_32_32;
00081   unsigned /* [0..255] */ MATCH_w_8_40;
00082   unsigned /* [0..65535] */ MATCH_w_16_40;
00083   unsigned /* [0..255] */ MATCH_w_8_48;
00084   unsigned MATCH_w_32_48;
00085   unsigned /* [0..255] */ MATCH_w_8_56;
00086   unsigned /* [0..65535] */ MATCH_w_16_56;
00087   unsigned MATCH_w_32_56;
00088   unsigned /* [0..255] */ MATCH_w_8_64;
00089   unsigned /* [0..65535] */ MATCH_w_16_64;
00090   unsigned /* [0..255] */ MATCH_w_8_72;
00091   { 
00092     MATCH_w_8_0 = getByte(MATCH_p); 
00093     
00094       switch((MATCH_w_8_0 >> 4 & 0xf) /* row at 0 */) {
00095         case 0: 
00096           if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) 
00097             
00098               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
00099                 case 0: 
00100                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
00101                   
00102                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
00103                       case 0: 
00104                         
00105                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
00106                             case 0: case 1: case 2: case 3: case 6: case 7: 
00107                               goto MATCH_label_a16; break;
00108                             case 4: 
00109                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
00110                               if ((MATCH_w_8_16 & 0x7) 
00111                                       /* base at 16 */ == 5 && 
00112                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00113                                       /* index at 16 */ && 
00114                                 (MATCH_w_8_16 >> 3 & 0x7) 
00115                                       /* index at 16 */ < 8)) 
00116                                 goto MATCH_label_a18;  /*opt-block+*/
00117                               else 
00118                                 goto MATCH_label_a17;  /*opt-block+*/
00119                               
00120                               break;
00121                             case 5: 
00122                               goto MATCH_label_a19; break;
00123                             default: assert(0);
00124                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
00125                         break;
00126                       case 1: 
00127                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
00128                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
00129                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00130                                 /* index at 16 */ && 
00131                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
00132                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
00133                           unsigned r8 = 
00134                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
00135                           nextPC = 4 + MATCH_p; 
00136                           
00137                           #line 1216 "machine/pentium/disassembler.m"
00138                           
00139 
00140                                   sprintf (str,  "ORmrb", DIS_EADDR8, DIS_R8);
00141 
00142                           
00143 
00144                           
00145                           
00146                           
00147                         } /*opt-block*//*opt-block+*/
00148                         else 
00149                           goto MATCH_label_a17;  /*opt-block+*/
00150                         
00151                         break;
00152                       case 2: 
00153                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
00154                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
00155                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00156                                 /* index at 16 */ && 
00157                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
00158                           goto MATCH_label_a18;  /*opt-block+*/
00159                         else 
00160                           goto MATCH_label_a19;  /*opt-block+*/
00161                         
00162                         break;
00163                       case 3: 
00164                         goto MATCH_label_a16; break;
00165                       default: assert(0);
00166                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
00167                   
00168                   break;
00169                 case 1: 
00170                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
00171                   
00172                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
00173                       case 0: 
00174                         
00175                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
00176                             case 0: case 1: case 2: case 3: case 6: case 7: 
00177                               goto MATCH_label_a20; break;
00178                             case 4: 
00179                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
00180                               if ((MATCH_w_8_16 & 0x7) 
00181                                       /* base at 16 */ == 5 && 
00182                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00183                                       /* index at 16 */ && 
00184                                 (MATCH_w_8_16 >> 3 & 0x7) 
00185                                       /* index at 16 */ < 8)) 
00186                                 goto MATCH_label_a22;  /*opt-block+*/
00187                               else 
00188                                 goto MATCH_label_a21;  /*opt-block+*/
00189                               
00190                               break;
00191                             case 5: 
00192                               goto MATCH_label_a23; break;
00193                             default: assert(0);
00194                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
00195                         break;
00196                       case 1: 
00197                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
00198                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
00199                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00200                                 /* index at 16 */ && 
00201                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
00202                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
00203                           unsigned reg = 
00204                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
00205                           nextPC = 4 + MATCH_p; 
00206                           
00207                           #line 1186 "machine/pentium/disassembler.m"
00208                           
00209 
00210                                   sprintf (str,  "ORmrod", DIS_EADDR32, DIS_REG32);
00211 
00212                           
00213 
00214                           
00215                           
00216                           
00217                         } /*opt-block*//*opt-block+*/
00218                         else 
00219                           goto MATCH_label_a21;  /*opt-block+*/
00220                         
00221                         break;
00222                       case 2: 
00223                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
00224                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
00225                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00226                                 /* index at 16 */ && 
00227                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
00228                           goto MATCH_label_a22;  /*opt-block+*/
00229                         else 
00230                           goto MATCH_label_a23;  /*opt-block+*/
00231                         
00232                         break;
00233                       case 3: 
00234                         goto MATCH_label_a20; break;
00235                       default: assert(0);
00236                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
00237                   
00238                   break;
00239                 case 2: 
00240                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
00241                   
00242                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
00243                       case 0: 
00244                         
00245                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
00246                             case 0: case 1: case 2: case 3: case 6: case 7: 
00247                               goto MATCH_label_a24; break;
00248                             case 4: 
00249                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
00250                               if ((MATCH_w_8_16 & 0x7) 
00251                                       /* base at 16 */ == 5 && 
00252                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00253                                       /* index at 16 */ && 
00254                                 (MATCH_w_8_16 >> 3 & 0x7) 
00255                                       /* index at 16 */ < 8)) 
00256                                 goto MATCH_label_a26;  /*opt-block+*/
00257                               else 
00258                                 goto MATCH_label_a25;  /*opt-block+*/
00259                               
00260                               break;
00261                             case 5: 
00262                               goto MATCH_label_a27; break;
00263                             default: assert(0);
00264                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
00265                         break;
00266                       case 1: 
00267                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
00268                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
00269                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00270                                 /* index at 16 */ && 
00271                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
00272                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
00273                           unsigned r8 = 
00274                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
00275                           nextPC = 4 + MATCH_p; 
00276                           
00277                           #line 1144 "machine/pentium/disassembler.m"
00278                           
00279 
00280                                   sprintf (str,  "ORrmb", DIS_R8, DIS_EADDR8);
00281 
00282                           
00283 
00284                           
00285                           
00286                           
00287                         } /*opt-block*//*opt-block+*/
00288                         else 
00289                           goto MATCH_label_a25;  /*opt-block+*/
00290                         
00291                         break;
00292                       case 2: 
00293                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
00294                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
00295                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00296                                 /* index at 16 */ && 
00297                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
00298                           goto MATCH_label_a26;  /*opt-block+*/
00299                         else 
00300                           goto MATCH_label_a27;  /*opt-block+*/
00301                         
00302                         break;
00303                       case 3: 
00304                         goto MATCH_label_a24; break;
00305                       default: assert(0);
00306                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
00307                   
00308                   break;
00309                 case 3: 
00310                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
00311                   
00312                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
00313                       case 0: 
00314                         
00315                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
00316                             case 0: case 1: case 2: case 3: case 6: case 7: 
00317                               goto MATCH_label_a28; break;
00318                             case 4: 
00319                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
00320                               if ((MATCH_w_8_16 & 0x7) 
00321                                       /* base at 16 */ == 5 && 
00322                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00323                                       /* index at 16 */ && 
00324                                 (MATCH_w_8_16 >> 3 & 0x7) 
00325                                       /* index at 16 */ < 8)) 
00326                                 goto MATCH_label_a30;  /*opt-block+*/
00327                               else 
00328                                 goto MATCH_label_a29;  /*opt-block+*/
00329                               
00330                               break;
00331                             case 5: 
00332                               goto MATCH_label_a31; break;
00333                             default: assert(0);
00334                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
00335                         break;
00336                       case 1: 
00337                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
00338                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
00339                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00340                                 /* index at 16 */ && 
00341                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
00342                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
00343                           unsigned reg = 
00344                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
00345                           nextPC = 4 + MATCH_p; 
00346                           
00347                           #line 1114 "machine/pentium/disassembler.m"
00348                           
00349 
00350                                   sprintf (str,  "ORrmod", DIS_REG32, DIS_EADDR32);
00351 
00352                           
00353 
00354                           
00355                           
00356                           
00357                         } /*opt-block*//*opt-block+*/
00358                         else 
00359                           goto MATCH_label_a29;  /*opt-block+*/
00360                         
00361                         break;
00362                       case 2: 
00363                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
00364                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
00365                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
00366                                 /* index at 16 */ && 
00367                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
00368                           goto MATCH_label_a30;  /*opt-block+*/
00369                         else 
00370                           goto MATCH_label_a31;  /*opt-block+*/
00371                         
00372                         break;
00373                       case 3: 
00374                         goto MATCH_label_a28; break;
00375                       default: assert(0);
00376                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
00377                   
00378                   break;
00379                 case 4: 
00380                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
00381                   { 
00382                     int /* [~128..127] */ i8 = 
00383                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
00384                     nextPC = 2 + MATCH_p; 
00385                     
00386                     #line 1408 "machine/pentium/disassembler.m"
00387                     
00388 
00389                             sprintf (str,  "ORiAL", DIS_I8);
00390 
00391                     
00392 
00393                     
00394                     
00395                     
00396                   }
00397                   
00398                   break;
00399                 case 5: 
00400                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
00401                   { 
00402                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
00403                     nextPC = 5 + MATCH_p; 
00404                     
00405                     #line 1360 "machine/pentium/disassembler.m"
00406                     
00407 
00408                             sprintf (str,  "ORiEAX", DIS_I32);
00409 
00410                     
00411 
00412                     
00413                     
00414                     
00415                   }
00416                   
00417                   break;
00418                 case 6: 
00419                   nextPC = 1 + MATCH_p; 
00420                   
00421                   #line 522 "machine/pentium/disassembler.m"
00422                   
00423 
00424                           sprintf (str,  "PUSH.CS");
00425 
00426                   
00427 
00428                   
00429                   
00430                   
00431                   
00432                   break;
00433                 case 7: 
00434                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
00435                   
00436                     switch((MATCH_w_8_8 >> 4 & 0xf) /* row at 8 */) {
00437                       case 0: 
00438                         
00439                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
00440                             case 0: 
00441                               if ((MATCH_w_8_8 >> 3 & 0x1) 
00442                                       /* page at 8 */ == 1) { 
00443                                 nextPC = 2 + MATCH_p; 
00444                                 
00445                                 #line 803 "machine/pentium/disassembler.m"
00446                                 
00447 
00448                                         sprintf (str,  "INVD");
00449 
00450                                 
00451 
00452                                 
00453                                 
00454                                 
00455                               } /*opt-block*//*opt-block+*/
00456                               else { 
00457                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
00458                                 
00459                                   switch((MATCH_w_8_16 >> 3 & 0x7) 
00460                                         /* reg_opcode at 16 */) {
00461                                     case 0: 
00462                                       
00463                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
00464                                               /* mod at 16 */) {
00465                                           case 0: 
00466                                             
00467                                               switch((MATCH_w_8_16 & 0x7) 
00468                                                     /* r_m at 16 */) {
00469                                                 case 0: case 1: case 2: 
00470                                                 case 3: case 6: case 7: 
00471                                                   goto MATCH_label_a32; break;
00472                                                 case 4: 
00473                                                   MATCH_w_8_24 = 
00474                                                     getByte(3 + MATCH_p); 
00475                                                   if ((MATCH_w_8_24 & 0x7) 
00476                                                           /* base at 24 */ == 5 && 
00477                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00478                                                           /* index at 24 */ && 
00479                                                     (MATCH_w_8_24 >> 3 & 0x7) 
00480                                                           /* index at 24 */ < 8)) 
00481                                                     goto MATCH_label_a34;  /*opt-block+*/
00482                                                   else 
00483                                                     goto MATCH_label_a33;  /*opt-block+*/
00484                                                   
00485                                                   break;
00486                                                 case 5: 
00487                                                   goto MATCH_label_a35; break;
00488                                                 default: assert(0);
00489                                               } /* (MATCH_w_8_16 & 0x7) 
00490                                                     -- r_m at 16 --*/ 
00491                                             break;
00492                                           case 1: 
00493                                             MATCH_w_8_24 = 
00494                                               getByte(3 + MATCH_p); 
00495                                             if ((MATCH_w_8_16 & 0x7) 
00496                                                     /* r_m at 16 */ == 4 && 
00497                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00498                                                     /* index at 24 */ && 
00499                                               (MATCH_w_8_24 >> 3 & 0x7) 
00500                                                     /* index at 24 */ < 8)) { 
00501                                               unsigned Eaddr = 
00502                                                 2 + addressToPC(MATCH_p);
00503                                               nextPC = 5 + MATCH_p; 
00504                                               
00505                                               #line 146 "machine/pentium/disassembler.m"
00506                                               
00507 
00508                                                       sprintf (str,  "SLDT", DIS_EADDR32);
00509 
00510                                               
00511 
00512                                               
00513                                               
00514                                               
00515                                             } /*opt-block*//*opt-block+*/
00516                                             else 
00517                                               goto MATCH_label_a33;  /*opt-block+*/
00518                                             
00519                                             break;
00520                                           case 2: 
00521                                             MATCH_w_8_24 = 
00522                                               getByte(3 + MATCH_p); 
00523                                             if ((MATCH_w_8_16 & 0x7) 
00524                                                     /* r_m at 16 */ == 4 && 
00525                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00526                                                     /* index at 24 */ && 
00527                                               (MATCH_w_8_24 >> 3 & 0x7) 
00528                                                     /* index at 24 */ < 8)) 
00529                                               goto MATCH_label_a34;  /*opt-block+*/
00530                                             else 
00531                                               goto MATCH_label_a35;  /*opt-block+*/
00532                                             
00533                                             break;
00534                                           case 3: 
00535                                             goto MATCH_label_a32; break;
00536                                           default: assert(0);
00537                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
00538                                               -- mod at 16 --*/ 
00539                                       break;
00540                                     case 1: 
00541                                       
00542                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
00543                                               /* mod at 16 */) {
00544                                           case 0: 
00545                                             
00546                                               switch((MATCH_w_8_16 & 0x7) 
00547                                                     /* r_m at 16 */) {
00548                                                 case 0: case 1: case 2: 
00549                                                 case 3: case 6: case 7: 
00550                                                   { 
00551                                                     unsigned Mem = 
00552                                                       2 + 
00553                                                       addressToPC(MATCH_p);
00554                                                     nextPC = 3 + MATCH_p; 
00555                                                     
00556                                                     #line 122 "machine/pentium/disassembler.m"
00557                                                     
00558 
00559                                                             sprintf (str,  "STR", DIS_MEM);
00560 
00561                                                     
00562 
00563                                                     
00564                                                     
00565                                                     
00566                                                   }
00567                                                   
00568                                                   break;
00569                                                 case 4: 
00570                                                   MATCH_w_8_24 = 
00571                                                     getByte(3 + MATCH_p); 
00572                                                   if ((MATCH_w_8_24 & 0x7) 
00573                                                           /* base at 24 */ == 5 && 
00574                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00575                                                           /* index at 24 */ && 
00576                                                     (MATCH_w_8_24 >> 3 & 0x7) 
00577                                                           /* index at 24 */ < 8)) 
00578                                                     goto MATCH_label_a37;  /*opt-block+*/
00579                                                   else 
00580                                                     goto MATCH_label_a36;  /*opt-block+*/
00581                                                   
00582                                                   break;
00583                                                 case 5: 
00584                                                   goto MATCH_label_a38; break;
00585                                                 default: assert(0);
00586                                               } /* (MATCH_w_8_16 & 0x7) 
00587                                                     -- r_m at 16 --*/ 
00588                                             break;
00589                                           case 1: 
00590                                             MATCH_w_8_24 = 
00591                                               getByte(3 + MATCH_p); 
00592                                             if ((MATCH_w_8_16 & 0x7) 
00593                                                     /* r_m at 16 */ == 4 && 
00594                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00595                                                     /* index at 24 */ && 
00596                                               (MATCH_w_8_24 >> 3 & 0x7) 
00597                                                     /* index at 24 */ < 8)) { 
00598                                               unsigned Mem = 
00599                                                 2 + addressToPC(MATCH_p);
00600                                               nextPC = 5 + MATCH_p; 
00601                                               
00602                                               #line 122 "machine/pentium/disassembler.m"
00603                                               
00604 
00605                                                       sprintf (str,  "STR", DIS_MEM);
00606 
00607                                               
00608 
00609                                               
00610                                               
00611                                               
00612                                             } /*opt-block*//*opt-block+*/
00613                                             else 
00614                                               goto MATCH_label_a36;  /*opt-block+*/
00615                                             
00616                                             break;
00617                                           case 2: 
00618                                             MATCH_w_8_24 = 
00619                                               getByte(3 + MATCH_p); 
00620                                             if ((MATCH_w_8_16 & 0x7) 
00621                                                     /* r_m at 16 */ == 4 && 
00622                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00623                                                     /* index at 24 */ && 
00624                                               (MATCH_w_8_24 >> 3 & 0x7) 
00625                                                     /* index at 24 */ < 8)) 
00626                                               goto MATCH_label_a37;  /*opt-block+*/
00627                                             else 
00628                                               goto MATCH_label_a38;  /*opt-block+*/
00629                                             
00630                                             break;
00631                                           case 3: 
00632                                             goto MATCH_label_a39; break;
00633                                           default: assert(0);
00634                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
00635                                               -- mod at 16 --*/ 
00636                                       break;
00637                                     case 2: case 6: case 7: 
00638                                       goto MATCH_label_a39; break;
00639                                     case 3: 
00640                                       
00641                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
00642                                               /* mod at 16 */) {
00643                                           case 0: 
00644                                             
00645                                               switch((MATCH_w_8_16 & 0x7) 
00646                                                     /* r_m at 16 */) {
00647                                                 case 0: case 1: case 2: 
00648                                                 case 3: case 6: case 7: 
00649                                                   goto MATCH_label_a40; break;
00650                                                 case 4: 
00651                                                   MATCH_w_8_24 = 
00652                                                     getByte(3 + MATCH_p); 
00653                                                   if ((MATCH_w_8_24 & 0x7) 
00654                                                           /* base at 24 */ == 5 && 
00655                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00656                                                           /* index at 24 */ && 
00657                                                     (MATCH_w_8_24 >> 3 & 0x7) 
00658                                                           /* index at 24 */ < 8)) 
00659                                                     goto MATCH_label_a42;  /*opt-block+*/
00660                                                   else 
00661                                                     goto MATCH_label_a41;  /*opt-block+*/
00662                                                   
00663                                                   break;
00664                                                 case 5: 
00665                                                   goto MATCH_label_a43; break;
00666                                                 default: assert(0);
00667                                               } /* (MATCH_w_8_16 & 0x7) 
00668                                                     -- r_m at 16 --*/ 
00669                                             break;
00670                                           case 1: 
00671                                             MATCH_w_8_24 = 
00672                                               getByte(3 + MATCH_p); 
00673                                             if ((MATCH_w_8_16 & 0x7) 
00674                                                     /* r_m at 16 */ == 4 && 
00675                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00676                                                     /* index at 24 */ && 
00677                                               (MATCH_w_8_24 >> 3 & 0x7) 
00678                                                     /* index at 24 */ < 8)) { 
00679                                               unsigned Eaddr = 
00680                                                 2 + addressToPC(MATCH_p);
00681                                               nextPC = 5 + MATCH_p; 
00682                                               
00683                                               #line 745 "machine/pentium/disassembler.m"
00684                                               
00685 
00686                                                       sprintf (str,  "LTR", DIS_EADDR32);
00687 
00688                                               
00689 
00690                                               
00691                                               
00692                                               
00693                                             } /*opt-block*//*opt-block+*/
00694                                             else 
00695                                               goto MATCH_label_a41;  /*opt-block+*/
00696                                             
00697                                             break;
00698                                           case 2: 
00699                                             MATCH_w_8_24 = 
00700                                               getByte(3 + MATCH_p); 
00701                                             if ((MATCH_w_8_16 & 0x7) 
00702                                                     /* r_m at 16 */ == 4 && 
00703                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00704                                                     /* index at 24 */ && 
00705                                               (MATCH_w_8_24 >> 3 & 0x7) 
00706                                                     /* index at 24 */ < 8)) 
00707                                               goto MATCH_label_a42;  /*opt-block+*/
00708                                             else 
00709                                               goto MATCH_label_a43;  /*opt-block+*/
00710                                             
00711                                             break;
00712                                           case 3: 
00713                                             goto MATCH_label_a40; break;
00714                                           default: assert(0);
00715                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
00716                                               -- mod at 16 --*/ 
00717                                       break;
00718                                     case 4: 
00719                                       
00720                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
00721                                               /* mod at 16 */) {
00722                                           case 0: 
00723                                             
00724                                               switch((MATCH_w_8_16 & 0x7) 
00725                                                     /* r_m at 16 */) {
00726                                                 case 0: case 1: case 2: 
00727                                                 case 3: case 6: case 7: 
00728                                                   goto MATCH_label_a44; break;
00729                                                 case 4: 
00730                                                   MATCH_w_8_24 = 
00731                                                     getByte(3 + MATCH_p); 
00732                                                   if ((MATCH_w_8_24 & 0x7) 
00733                                                           /* base at 24 */ == 5 && 
00734                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00735                                                           /* index at 24 */ && 
00736                                                     (MATCH_w_8_24 >> 3 & 0x7) 
00737                                                           /* index at 24 */ < 8)) 
00738                                                     goto MATCH_label_a46;  /*opt-block+*/
00739                                                   else 
00740                                                     goto MATCH_label_a45;  /*opt-block+*/
00741                                                   
00742                                                   break;
00743                                                 case 5: 
00744                                                   goto MATCH_label_a47; break;
00745                                                 default: assert(0);
00746                                               } /* (MATCH_w_8_16 & 0x7) 
00747                                                     -- r_m at 16 --*/ 
00748                                             break;
00749                                           case 1: 
00750                                             MATCH_w_8_24 = 
00751                                               getByte(3 + MATCH_p); 
00752                                             if ((MATCH_w_8_16 & 0x7) 
00753                                                     /* r_m at 16 */ == 4 && 
00754                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00755                                                     /* index at 24 */ && 
00756                                               (MATCH_w_8_24 >> 3 & 0x7) 
00757                                                     /* index at 24 */ < 8)) { 
00758                                               unsigned Eaddr = 
00759                                                 2 + addressToPC(MATCH_p);
00760                                               nextPC = 5 + MATCH_p; 
00761                                               
00762                                               #line 92 "machine/pentium/disassembler.m"
00763                                               
00764 
00765                                                       sprintf (str,  "VERR", DIS_EADDR32);
00766 
00767                                               
00768 
00769                                               
00770                                               
00771                                               
00772                                             } /*opt-block*//*opt-block+*/
00773                                             else 
00774                                               goto MATCH_label_a45;  /*opt-block+*/
00775                                             
00776                                             break;
00777                                           case 2: 
00778                                             MATCH_w_8_24 = 
00779                                               getByte(3 + MATCH_p); 
00780                                             if ((MATCH_w_8_16 & 0x7) 
00781                                                     /* r_m at 16 */ == 4 && 
00782                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00783                                                     /* index at 24 */ && 
00784                                               (MATCH_w_8_24 >> 3 & 0x7) 
00785                                                     /* index at 24 */ < 8)) 
00786                                               goto MATCH_label_a46;  /*opt-block+*/
00787                                             else 
00788                                               goto MATCH_label_a47;  /*opt-block+*/
00789                                             
00790                                             break;
00791                                           case 3: 
00792                                             goto MATCH_label_a44; break;
00793                                           default: assert(0);
00794                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
00795                                               -- mod at 16 --*/ 
00796                                       break;
00797                                     case 5: 
00798                                       
00799                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
00800                                               /* mod at 16 */) {
00801                                           case 0: 
00802                                             
00803                                               switch((MATCH_w_8_16 & 0x7) 
00804                                                     /* r_m at 16 */) {
00805                                                 case 0: case 1: case 2: 
00806                                                 case 3: case 6: case 7: 
00807                                                   goto MATCH_label_a48; break;
00808                                                 case 4: 
00809                                                   MATCH_w_8_24 = 
00810                                                     getByte(3 + MATCH_p); 
00811                                                   if ((MATCH_w_8_24 & 0x7) 
00812                                                           /* base at 24 */ == 5 && 
00813                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00814                                                           /* index at 24 */ && 
00815                                                     (MATCH_w_8_24 >> 3 & 0x7) 
00816                                                           /* index at 24 */ < 8)) 
00817                                                     goto MATCH_label_a50;  /*opt-block+*/
00818                                                   else 
00819                                                     goto MATCH_label_a49;  /*opt-block+*/
00820                                                   
00821                                                   break;
00822                                                 case 5: 
00823                                                   goto MATCH_label_a51; break;
00824                                                 default: assert(0);
00825                                               } /* (MATCH_w_8_16 & 0x7) 
00826                                                     -- r_m at 16 --*/ 
00827                                             break;
00828                                           case 1: 
00829                                             MATCH_w_8_24 = 
00830                                               getByte(3 + MATCH_p); 
00831                                             if ((MATCH_w_8_16 & 0x7) 
00832                                                     /* r_m at 16 */ == 4 && 
00833                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00834                                                     /* index at 24 */ && 
00835                                               (MATCH_w_8_24 >> 3 & 0x7) 
00836                                                     /* index at 24 */ < 8)) { 
00837                                               unsigned Eaddr = 
00838                                                 2 + addressToPC(MATCH_p);
00839                                               nextPC = 5 + MATCH_p; 
00840                                               
00841                                               #line 89 "machine/pentium/disassembler.m"
00842                                               
00843 
00844                                                       sprintf (str,  "VERW", DIS_EADDR32);
00845 
00846                                               
00847 
00848                                               
00849                                               
00850                                               
00851                                             } /*opt-block*//*opt-block+*/
00852                                             else 
00853                                               goto MATCH_label_a49;  /*opt-block+*/
00854                                             
00855                                             break;
00856                                           case 2: 
00857                                             MATCH_w_8_24 = 
00858                                               getByte(3 + MATCH_p); 
00859                                             if ((MATCH_w_8_16 & 0x7) 
00860                                                     /* r_m at 16 */ == 4 && 
00861                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00862                                                     /* index at 24 */ && 
00863                                               (MATCH_w_8_24 >> 3 & 0x7) 
00864                                                     /* index at 24 */ < 8)) 
00865                                               goto MATCH_label_a50;  /*opt-block+*/
00866                                             else 
00867                                               goto MATCH_label_a51;  /*opt-block+*/
00868                                             
00869                                             break;
00870                                           case 3: 
00871                                             goto MATCH_label_a48; break;
00872                                           default: assert(0);
00873                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
00874                                               -- mod at 16 --*/ 
00875                                       break;
00876                                     default: assert(0);
00877                                   } /* (MATCH_w_8_16 >> 3 & 0x7) 
00878                                         -- reg_opcode at 16 --*/ 
00879                                 
00880                               } /*opt-block*/
00881                               break;
00882                             case 1: 
00883                               if ((MATCH_w_8_8 >> 3 & 0x1) 
00884                                       /* page at 8 */ == 1) { 
00885                                 nextPC = 2 + MATCH_p; 
00886                                 
00887                                 #line 83 "machine/pentium/disassembler.m"
00888                                 
00889 
00890                                         sprintf (str,  "WBINVD");
00891 
00892                                 
00893 
00894                                 
00895                                 
00896                                 
00897                               } /*opt-block*//*opt-block+*/
00898                               else { 
00899                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
00900                                 
00901                                   switch((MATCH_w_8_16 >> 3 & 0x7) 
00902                                         /* reg_opcode at 16 */) {
00903                                     case 0: 
00904                                       
00905                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
00906                                               /* mod at 16 */) {
00907                                           case 0: 
00908                                             
00909                                               switch((MATCH_w_8_16 & 0x7) 
00910                                                     /* r_m at 16 */) {
00911                                                 case 0: case 1: case 2: 
00912                                                 case 3: case 6: case 7: 
00913                                                   { 
00914                                                     unsigned Mem = 
00915                                                       2 + 
00916                                                       addressToPC(MATCH_p);
00917                                                     nextPC = 3 + MATCH_p; 
00918                                                     
00919                                                     #line 176 "machine/pentium/disassembler.m"
00920                                                     
00921 
00922                                                             sprintf (str,  "SGDT", DIS_MEM);
00923 
00924                                                     
00925 
00926                                                         // Sets are now in the high level instructions
00927 
00928                                                     
00929                                                     
00930                                                     
00931                                                   }
00932                                                   
00933                                                   break;
00934                                                 case 4: 
00935                                                   MATCH_w_8_24 = 
00936                                                     getByte(3 + MATCH_p); 
00937                                                   if ((MATCH_w_8_24 & 0x7) 
00938                                                           /* base at 24 */ == 5 && 
00939                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00940                                                           /* index at 24 */ && 
00941                                                     (MATCH_w_8_24 >> 3 & 0x7) 
00942                                                           /* index at 24 */ < 8)) 
00943                                                     goto MATCH_label_a53;  /*opt-block+*/
00944                                                   else 
00945                                                     goto MATCH_label_a52;  /*opt-block+*/
00946                                                   
00947                                                   break;
00948                                                 case 5: 
00949                                                   goto MATCH_label_a54; break;
00950                                                 default: assert(0);
00951                                               } /* (MATCH_w_8_16 & 0x7) 
00952                                                     -- r_m at 16 --*/ 
00953                                             break;
00954                                           case 1: 
00955                                             MATCH_w_8_24 = 
00956                                               getByte(3 + MATCH_p); 
00957                                             if ((MATCH_w_8_16 & 0x7) 
00958                                                     /* r_m at 16 */ == 4 && 
00959                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00960                                                     /* index at 24 */ && 
00961                                               (MATCH_w_8_24 >> 3 & 0x7) 
00962                                                     /* index at 24 */ < 8)) { 
00963                                               unsigned Mem = 
00964                                                 2 + addressToPC(MATCH_p);
00965                                               nextPC = 5 + MATCH_p; 
00966                                               
00967                                               #line 176 "machine/pentium/disassembler.m"
00968                                               
00969 
00970                                                       sprintf (str,  "SGDT", DIS_MEM);
00971 
00972                                               
00973 
00974                                                   // Sets are now in the high level instructions
00975 
00976                                               
00977                                               
00978                                               
00979                                             } /*opt-block*//*opt-block+*/
00980                                             else 
00981                                               goto MATCH_label_a52;  /*opt-block+*/
00982                                             
00983                                             break;
00984                                           case 2: 
00985                                             MATCH_w_8_24 = 
00986                                               getByte(3 + MATCH_p); 
00987                                             if ((MATCH_w_8_16 & 0x7) 
00988                                                     /* r_m at 16 */ == 4 && 
00989                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
00990                                                     /* index at 24 */ && 
00991                                               (MATCH_w_8_24 >> 3 & 0x7) 
00992                                                     /* index at 24 */ < 8)) 
00993                                               goto MATCH_label_a53;  /*opt-block+*/
00994                                             else 
00995                                               goto MATCH_label_a54;  /*opt-block+*/
00996                                             
00997                                             break;
00998                                           case 3: 
00999                                             goto MATCH_label_a39; break;
01000                                           default: assert(0);
01001                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
01002                                               -- mod at 16 --*/ 
01003                                       break;
01004                                     case 1: 
01005                                       
01006                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
01007                                               /* mod at 16 */) {
01008                                           case 0: 
01009                                             
01010                                               switch((MATCH_w_8_16 & 0x7) 
01011                                                     /* r_m at 16 */) {
01012                                                 case 0: case 1: case 2: 
01013                                                 case 3: case 6: case 7: 
01014                                                   { 
01015                                                     unsigned Mem = 
01016                                                       2 + 
01017                                                       addressToPC(MATCH_p);
01018                                                     nextPC = 3 + MATCH_p; 
01019                                                     
01020                                                     #line 173 "machine/pentium/disassembler.m"
01021                                                     
01022 
01023                                                             sprintf (str,  "SIDT", DIS_MEM);
01024 
01025                                                     
01026 
01027                                                     
01028                                                     
01029                                                     
01030                                                   }
01031                                                   
01032                                                   break;
01033                                                 case 4: 
01034                                                   MATCH_w_8_24 = 
01035                                                     getByte(3 + MATCH_p); 
01036                                                   if ((MATCH_w_8_24 & 0x7) 
01037                                                           /* base at 24 */ == 5 && 
01038                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01039                                                           /* index at 24 */ && 
01040                                                     (MATCH_w_8_24 >> 3 & 0x7) 
01041                                                           /* index at 24 */ < 8)) 
01042                                                     goto MATCH_label_a56;  /*opt-block+*/
01043                                                   else 
01044                                                     goto MATCH_label_a55;  /*opt-block+*/
01045                                                   
01046                                                   break;
01047                                                 case 5: 
01048                                                   goto MATCH_label_a57; break;
01049                                                 default: assert(0);
01050                                               } /* (MATCH_w_8_16 & 0x7) 
01051                                                     -- r_m at 16 --*/ 
01052                                             break;
01053                                           case 1: 
01054                                             MATCH_w_8_24 = 
01055                                               getByte(3 + MATCH_p); 
01056                                             if ((MATCH_w_8_16 & 0x7) 
01057                                                     /* r_m at 16 */ == 4 && 
01058                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01059                                                     /* index at 24 */ && 
01060                                               (MATCH_w_8_24 >> 3 & 0x7) 
01061                                                     /* index at 24 */ < 8)) { 
01062                                               unsigned Mem = 
01063                                                 2 + addressToPC(MATCH_p);
01064                                               nextPC = 5 + MATCH_p; 
01065                                               
01066                                               #line 173 "machine/pentium/disassembler.m"
01067                                               
01068 
01069                                                       sprintf (str,  "SIDT", DIS_MEM);
01070 
01071                                               
01072 
01073                                               
01074                                               
01075                                               
01076                                             } /*opt-block*//*opt-block+*/
01077                                             else 
01078                                               goto MATCH_label_a55;  /*opt-block+*/
01079                                             
01080                                             break;
01081                                           case 2: 
01082                                             MATCH_w_8_24 = 
01083                                               getByte(3 + MATCH_p); 
01084                                             if ((MATCH_w_8_16 & 0x7) 
01085                                                     /* r_m at 16 */ == 4 && 
01086                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01087                                                     /* index at 24 */ && 
01088                                               (MATCH_w_8_24 >> 3 & 0x7) 
01089                                                     /* index at 24 */ < 8)) 
01090                                               goto MATCH_label_a56;  /*opt-block+*/
01091                                             else 
01092                                               goto MATCH_label_a57;  /*opt-block+*/
01093                                             
01094                                             break;
01095                                           case 3: 
01096                                             goto MATCH_label_a39; break;
01097                                           default: assert(0);
01098                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
01099                                               -- mod at 16 --*/ 
01100                                       break;
01101                                     case 2: case 3: case 5: case 6: 
01102                                       goto MATCH_label_a39; break;
01103                                     case 4: 
01104                                       
01105                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
01106                                               /* mod at 16 */) {
01107                                           case 0: 
01108                                             
01109                                               switch((MATCH_w_8_16 & 0x7) 
01110                                                     /* r_m at 16 */) {
01111                                                 case 0: case 1: case 2: 
01112                                                 case 3: case 6: case 7: 
01113                                                   goto MATCH_label_a58; break;
01114                                                 case 4: 
01115                                                   MATCH_w_8_24 = 
01116                                                     getByte(3 + MATCH_p); 
01117                                                   if ((MATCH_w_8_24 & 0x7) 
01118                                                           /* base at 24 */ == 5 && 
01119                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01120                                                           /* index at 24 */ && 
01121                                                     (MATCH_w_8_24 >> 3 & 0x7) 
01122                                                           /* index at 24 */ < 8)) 
01123                                                     goto MATCH_label_a60;  /*opt-block+*/
01124                                                   else 
01125                                                     goto MATCH_label_a59;  /*opt-block+*/
01126                                                   
01127                                                   break;
01128                                                 case 5: 
01129                                                   goto MATCH_label_a61; break;
01130                                                 default: assert(0);
01131                                               } /* (MATCH_w_8_16 & 0x7) 
01132                                                     -- r_m at 16 --*/ 
01133                                             break;
01134                                           case 1: 
01135                                             MATCH_w_8_24 = 
01136                                               getByte(3 + MATCH_p); 
01137                                             if ((MATCH_w_8_16 & 0x7) 
01138                                                     /* r_m at 16 */ == 4 && 
01139                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01140                                                     /* index at 24 */ && 
01141                                               (MATCH_w_8_24 >> 3 & 0x7) 
01142                                                     /* index at 24 */ < 8)) { 
01143                                               unsigned Eaddr = 
01144                                                 2 + addressToPC(MATCH_p);
01145                                               nextPC = 5 + MATCH_p; 
01146                                               
01147                                               #line 143 "machine/pentium/disassembler.m"
01148                                               
01149 
01150                                                       sprintf (str,  "SMSW", DIS_EADDR32);
01151 
01152                                               
01153 
01154                                               
01155                                               
01156                                               
01157                                             } /*opt-block*//*opt-block+*/
01158                                             else 
01159                                               goto MATCH_label_a59;  /*opt-block+*/
01160                                             
01161                                             break;
01162                                           case 2: 
01163                                             MATCH_w_8_24 = 
01164                                               getByte(3 + MATCH_p); 
01165                                             if ((MATCH_w_8_16 & 0x7) 
01166                                                     /* r_m at 16 */ == 4 && 
01167                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01168                                                     /* index at 24 */ && 
01169                                               (MATCH_w_8_24 >> 3 & 0x7) 
01170                                                     /* index at 24 */ < 8)) 
01171                                               goto MATCH_label_a60;  /*opt-block+*/
01172                                             else 
01173                                               goto MATCH_label_a61;  /*opt-block+*/
01174                                             
01175                                             break;
01176                                           case 3: 
01177                                             goto MATCH_label_a58; break;
01178                                           default: assert(0);
01179                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
01180                                               -- mod at 16 --*/ 
01181                                       break;
01182                                     case 7: 
01183                                       
01184                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
01185                                               /* mod at 16 */) {
01186                                           case 0: 
01187                                             
01188                                               switch((MATCH_w_8_16 & 0x7) 
01189                                                     /* r_m at 16 */) {
01190                                                 case 0: case 1: case 2: 
01191                                                 case 3: case 6: case 7: 
01192                                                   { 
01193                                                     unsigned Mem = 
01194                                                       2 + 
01195                                                       addressToPC(MATCH_p);
01196                                                     nextPC = 3 + MATCH_p; 
01197                                                     
01198                                                     #line 800 "machine/pentium/disassembler.m"
01199                                                     
01200 
01201                                                             sprintf (str,  "INVLPG", DIS_MEM);
01202 
01203                                                     
01204 
01205                                                     
01206                                                     
01207                                                     
01208                                                   }
01209                                                   
01210                                                   break;
01211                                                 case 4: 
01212                                                   MATCH_w_8_24 = 
01213                                                     getByte(3 + MATCH_p); 
01214                                                   if ((MATCH_w_8_24 & 0x7) 
01215                                                           /* base at 24 */ == 5 && 
01216                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01217                                                           /* index at 24 */ && 
01218                                                     (MATCH_w_8_24 >> 3 & 0x7) 
01219                                                           /* index at 24 */ < 8)) 
01220                                                     goto MATCH_label_a63;  /*opt-block+*/
01221                                                   else 
01222                                                     goto MATCH_label_a62;  /*opt-block+*/
01223                                                   
01224                                                   break;
01225                                                 case 5: 
01226                                                   goto MATCH_label_a64; break;
01227                                                 default: assert(0);
01228                                               } /* (MATCH_w_8_16 & 0x7) 
01229                                                     -- r_m at 16 --*/ 
01230                                             break;
01231                                           case 1: 
01232                                             MATCH_w_8_24 = 
01233                                               getByte(3 + MATCH_p); 
01234                                             if ((MATCH_w_8_16 & 0x7) 
01235                                                     /* r_m at 16 */ == 4 && 
01236                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01237                                                     /* index at 24 */ && 
01238                                               (MATCH_w_8_24 >> 3 & 0x7) 
01239                                                     /* index at 24 */ < 8)) { 
01240                                               unsigned Mem = 
01241                                                 2 + addressToPC(MATCH_p);
01242                                               nextPC = 5 + MATCH_p; 
01243                                               
01244                                               #line 800 "machine/pentium/disassembler.m"
01245                                               
01246 
01247                                                       sprintf (str,  "INVLPG", DIS_MEM);
01248 
01249                                               
01250 
01251                                               
01252                                               
01253                                               
01254                                             } /*opt-block*//*opt-block+*/
01255                                             else 
01256                                               goto MATCH_label_a62;  /*opt-block+*/
01257                                             
01258                                             break;
01259                                           case 2: 
01260                                             MATCH_w_8_24 = 
01261                                               getByte(3 + MATCH_p); 
01262                                             if ((MATCH_w_8_16 & 0x7) 
01263                                                     /* r_m at 16 */ == 4 && 
01264                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01265                                                     /* index at 24 */ && 
01266                                               (MATCH_w_8_24 >> 3 & 0x7) 
01267                                                     /* index at 24 */ < 8)) 
01268                                               goto MATCH_label_a63;  /*opt-block+*/
01269                                             else 
01270                                               goto MATCH_label_a64;  /*opt-block+*/
01271                                             
01272                                             break;
01273                                           case 3: 
01274                                             goto MATCH_label_a39; break;
01275                                           default: assert(0);
01276                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
01277                                               -- mod at 16 --*/ 
01278                                       break;
01279                                     default: assert(0);
01280                                   } /* (MATCH_w_8_16 >> 3 & 0x7) 
01281                                         -- reg_opcode at 16 --*/ 
01282                                 
01283                               } /*opt-block*/
01284                               break;
01285                             case 2: 
01286                               if ((MATCH_w_8_8 >> 3 & 0x1) 
01287                                       /* page at 8 */ == 1) 
01288                                 goto MATCH_label_a39;  /*opt-block+*/
01289                               else { 
01290                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
01291                                 
01292                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
01293                                         /* mod at 16 */) {
01294                                     case 0: 
01295                                       
01296                                         switch((MATCH_w_8_16 & 0x7) 
01297                                               /* r_m at 16 */) {
01298                                           case 0: case 1: case 2: case 3: 
01299                                           case 6: case 7: 
01300                                             goto MATCH_label_a65; break;
01301                                           case 4: 
01302                                             MATCH_w_8_24 = 
01303                                               getByte(3 + MATCH_p); 
01304                                             if ((MATCH_w_8_24 & 0x7) 
01305                                                     /* base at 24 */ == 5 && 
01306                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01307                                                     /* index at 24 */ && 
01308                                               (MATCH_w_8_24 >> 3 & 0x7) 
01309                                                     /* index at 24 */ < 8)) 
01310                                               goto MATCH_label_a67;  /*opt-block+*/
01311                                             else 
01312                                               goto MATCH_label_a66;  /*opt-block+*/
01313                                             
01314                                             break;
01315                                           case 5: 
01316                                             goto MATCH_label_a68; break;
01317                                           default: assert(0);
01318                                         } /* (MATCH_w_8_16 & 0x7) 
01319                                               -- r_m at 16 --*/ 
01320                                       break;
01321                                     case 1: 
01322                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
01323                                       if ((MATCH_w_8_16 & 0x7) 
01324                                               /* r_m at 16 */ == 4 && 
01325                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01326                                               /* index at 24 */ && 
01327                                         (MATCH_w_8_24 >> 3 & 0x7) 
01328                                               /* index at 24 */ < 8)) { 
01329                                         unsigned Eaddr = 
01330                                           2 + addressToPC(MATCH_p);
01331                                         unsigned reg = 
01332                                           (MATCH_w_8_16 >> 3 & 0x7) 
01333                                                 /* reg_opcode at 16 */;
01334                                         nextPC = 5 + MATCH_p; 
01335                                         
01336                                         #line 787 "machine/pentium/disassembler.m"
01337                                         
01338 
01339                                                 sprintf (str,  "LAR.od", DIS_REG32, DIS_EADDR32);
01340 
01341                                         
01342 
01343                                         
01344                                         
01345                                         
01346                                       } /*opt-block*//*opt-block+*/
01347                                       else 
01348                                         goto MATCH_label_a66;  /*opt-block+*/
01349                                       
01350                                       break;
01351                                     case 2: 
01352                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
01353                                       if ((MATCH_w_8_16 & 0x7) 
01354                                               /* r_m at 16 */ == 4 && 
01355                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01356                                               /* index at 24 */ && 
01357                                         (MATCH_w_8_24 >> 3 & 0x7) 
01358                                               /* index at 24 */ < 8)) 
01359                                         goto MATCH_label_a67;  /*opt-block+*/
01360                                       else 
01361                                         goto MATCH_label_a68;  /*opt-block+*/
01362                                       
01363                                       break;
01364                                     case 3: 
01365                                       goto MATCH_label_a65; break;
01366                                     default: assert(0);
01367                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
01368                                         -- mod at 16 --*/ 
01369                                 
01370                               } /*opt-block*/
01371                               break;
01372                             case 3: 
01373                               if ((MATCH_w_8_8 >> 3 & 0x1) 
01374                                       /* page at 8 */ == 1) 
01375                                 goto MATCH_label_a39;  /*opt-block+*/
01376                               else { 
01377                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
01378                                 
01379                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
01380                                         /* mod at 16 */) {
01381                                     case 0: 
01382                                       
01383                                         switch((MATCH_w_8_16 & 0x7) 
01384                                               /* r_m at 16 */) {
01385                                           case 0: case 1: case 2: case 3: 
01386                                           case 6: case 7: 
01387                                             goto MATCH_label_a69; break;
01388                                           case 4: 
01389                                             MATCH_w_8_24 = 
01390                                               getByte(3 + MATCH_p); 
01391                                             if ((MATCH_w_8_24 & 0x7) 
01392                                                     /* base at 24 */ == 5 && 
01393                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01394                                                     /* index at 24 */ && 
01395                                               (MATCH_w_8_24 >> 3 & 0x7) 
01396                                                     /* index at 24 */ < 8)) 
01397                                               goto MATCH_label_a71;  /*opt-block+*/
01398                                             else 
01399                                               goto MATCH_label_a70;  /*opt-block+*/
01400                                             
01401                                             break;
01402                                           case 5: 
01403                                             goto MATCH_label_a72; break;
01404                                           default: assert(0);
01405                                         } /* (MATCH_w_8_16 & 0x7) 
01406                                               -- r_m at 16 --*/ 
01407                                       break;
01408                                     case 1: 
01409                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
01410                                       if ((MATCH_w_8_16 & 0x7) 
01411                                               /* r_m at 16 */ == 4 && 
01412                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01413                                               /* index at 24 */ && 
01414                                         (MATCH_w_8_24 >> 3 & 0x7) 
01415                                               /* index at 24 */ < 8)) { 
01416                                         unsigned Eaddr = 
01417                                           2 + addressToPC(MATCH_p);
01418                                         unsigned reg = 
01419                                           (MATCH_w_8_16 >> 3 & 0x7) 
01420                                                 /* reg_opcode at 16 */;
01421                                         nextPC = 5 + MATCH_p; 
01422                                         
01423                                         #line 751 "machine/pentium/disassembler.m"
01424                                         
01425 
01426                                                 sprintf (str,  "LSLod", DIS_REG32, DIS_EADDR32);
01427 
01428                                         
01429 
01430                                         
01431                                         
01432                                         
01433                                       } /*opt-block*//*opt-block+*/
01434                                       else 
01435                                         goto MATCH_label_a70;  /*opt-block+*/
01436                                       
01437                                       break;
01438                                     case 2: 
01439                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
01440                                       if ((MATCH_w_8_16 & 0x7) 
01441                                               /* r_m at 16 */ == 4 && 
01442                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01443                                               /* index at 24 */ && 
01444                                         (MATCH_w_8_24 >> 3 & 0x7) 
01445                                               /* index at 24 */ < 8)) 
01446                                         goto MATCH_label_a71;  /*opt-block+*/
01447                                       else 
01448                                         goto MATCH_label_a72;  /*opt-block+*/
01449                                       
01450                                       break;
01451                                     case 3: 
01452                                       goto MATCH_label_a69; break;
01453                                     default: assert(0);
01454                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
01455                                         -- mod at 16 --*/ 
01456                                 
01457                               } /*opt-block*/
01458                               break;
01459                             case 4: case 5: case 7: 
01460                               goto MATCH_label_a39; break;
01461                             case 6: 
01462                               if ((MATCH_w_8_8 >> 3 & 0x1) 
01463                                       /* page at 8 */ == 0) { 
01464                                 nextPC = 2 + MATCH_p; 
01465                                 
01466                                 #line 962 "machine/pentium/disassembler.m"
01467                                 
01468 
01469                                         sprintf (str,  "CLTS");
01470 
01471                                 
01472 
01473                                 
01474                                 
01475                                 
01476                               } /*opt-block*//*opt-block+*/
01477                               else 
01478                                 goto MATCH_label_a39;  /*opt-block+*/
01479                               
01480                               break;
01481                             default: assert(0);
01482                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
01483                         break;
01484                       case 1: case 2: case 3: case 5: case 6: case 7: case 8: 
01485                       case 9: case 13: case 14: case 15: 
01486                         goto MATCH_label_a39; break;
01487                       case 4: 
01488                         
01489                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
01490                             case 0: 
01491                               if ((MATCH_w_8_8 >> 3 & 0x1) 
01492                                       /* page at 8 */ == 0) { 
01493                                 nextPC = 2 + MATCH_p; 
01494                                 
01495                                 #line 80 "machine/pentium/disassembler.m"
01496                                 
01497 
01498                                         sprintf (str,  "WRMSR");
01499 
01500                                 
01501 
01502                                 
01503                                 
01504                                 
01505                               } /*opt-block*//*opt-block+*/
01506                               else 
01507                                 goto MATCH_label_a39;  /*opt-block+*/
01508                               
01509                               break;
01510                             case 1: case 3: case 4: case 5: case 6: case 7: 
01511                               goto MATCH_label_a39; break;
01512                             case 2: 
01513                               if ((MATCH_w_8_8 >> 3 & 0x1) 
01514                                       /* page at 8 */ == 0) { 
01515                                 nextPC = 2 + MATCH_p; 
01516                                 
01517                                 #line 303 "machine/pentium/disassembler.m"
01518                                 
01519 
01520                                         sprintf (str,  "RDMSR");
01521 
01522                                 
01523 
01524                                 
01525                                 
01526                                 
01527                               } /*opt-block*//*opt-block+*/
01528                               else 
01529                                 goto MATCH_label_a39;  /*opt-block+*/
01530                               
01531                               break;
01532                             default: assert(0);
01533                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
01534                         break;
01535                       case 10: 
01536                         
01537                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
01538                             case 0: 
01539                               if ((MATCH_w_8_8 >> 3 & 0x1) 
01540                                       /* page at 8 */ == 1) { 
01541                                 nextPC = 2 + MATCH_p; 
01542                                 
01543                                 #line 507 "machine/pentium/disassembler.m"
01544                                 
01545 
01546                                         sprintf (str,  "PUSH.GS");
01547 
01548                                 
01549 
01550                                 
01551                                 
01552                                 
01553                               } /*opt-block*//*opt-block+*/
01554                               else { 
01555                                 nextPC = 2 + MATCH_p; 
01556                                 
01557                                 #line 510 "machine/pentium/disassembler.m"
01558                                 
01559 
01560                                         sprintf (str,  "PUSH.FS");
01561 
01562                                 
01563 
01564                                 
01565                                 
01566                                 
01567                               } /*opt-block*//*opt-block+*/
01568                               
01569                               break;
01570                             case 1: 
01571                               if ((MATCH_w_8_8 >> 3 & 0x1) 
01572                                       /* page at 8 */ == 1) { 
01573                                 nextPC = 2 + MATCH_p; 
01574                                 
01575                                 #line 561 "machine/pentium/disassembler.m"
01576                                 
01577 
01578                                         sprintf (str,  "POP.GS");
01579 
01580                                 
01581 
01582                                 
01583                                 
01584                                 
01585                               } /*opt-block*//*opt-block+*/
01586                               else { 
01587                                 nextPC = 2 + MATCH_p; 
01588                                 
01589                                 #line 564 "machine/pentium/disassembler.m"
01590                                 
01591 
01592                                         sprintf (str,  "POP.FS");
01593 
01594                                 
01595 
01596                                 
01597                                 
01598                                 
01599                               } /*opt-block*//*opt-block+*/
01600                               
01601                               break;
01602                             case 2: 
01603                               if ((MATCH_w_8_8 >> 3 & 0x1) 
01604                                       /* page at 8 */ == 1) { 
01605                                 nextPC = 2 + MATCH_p; 
01606                                 
01607                                 #line 192 "machine/pentium/disassembler.m"
01608                                 
01609 
01610                                         sprintf (str,  "RSM");
01611 
01612                                 
01613 
01614                                 
01615                                 
01616                                 
01617                               } /*opt-block*//*opt-block+*/
01618                               else { 
01619                                 nextPC = 2 + MATCH_p; 
01620                                 
01621                                 #line 935 "machine/pentium/disassembler.m"
01622                                 
01623 
01624                                         sprintf (str,  "CPUID");
01625 
01626                                 
01627 
01628                                 
01629                                 
01630                                 
01631                               } /*opt-block*//*opt-block+*/
01632                               
01633                               break;
01634                             case 3: 
01635                               if ((MATCH_w_8_8 >> 3 & 0x1) 
01636                                       /* page at 8 */ == 1) { 
01637                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
01638                                 
01639                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
01640                                         /* mod at 16 */) {
01641                                     case 0: 
01642                                       
01643                                         switch((MATCH_w_8_16 & 0x7) 
01644                                               /* r_m at 16 */) {
01645                                           case 0: case 1: case 2: case 3: 
01646                                           case 6: case 7: 
01647                                             goto MATCH_label_a77; break;
01648                                           case 4: 
01649                                             MATCH_w_8_24 = 
01650                                               getByte(3 + MATCH_p); 
01651                                             if ((MATCH_w_8_24 & 0x7) 
01652                                                     /* base at 24 */ == 5 && 
01653                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01654                                                     /* index at 24 */ && 
01655                                               (MATCH_w_8_24 >> 3 & 0x7) 
01656                                                     /* index at 24 */ < 8)) 
01657                                               goto MATCH_label_a79;  /*opt-block+*/
01658                                             else 
01659                                               goto MATCH_label_a78;  /*opt-block+*/
01660                                             
01661                                             break;
01662                                           case 5: 
01663                                             goto MATCH_label_a80; break;
01664                                           default: assert(0);
01665                                         } /* (MATCH_w_8_16 & 0x7) 
01666                                               -- r_m at 16 --*/ 
01667                                       break;
01668                                     case 1: 
01669                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
01670                                       if ((MATCH_w_8_16 & 0x7) 
01671                                               /* r_m at 16 */ == 4 && 
01672                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01673                                               /* index at 24 */ && 
01674                                         (MATCH_w_8_24 >> 3 & 0x7) 
01675                                               /* index at 24 */ < 8)) { 
01676                                         unsigned Eaddr = 
01677                                           2 + addressToPC(MATCH_p);
01678                                         unsigned reg = 
01679                                           (MATCH_w_8_16 >> 3 & 0x7) 
01680                                                 /* reg_opcode at 16 */;
01681                                         nextPC = 5 + MATCH_p; 
01682                                         
01683                                         #line 998 "machine/pentium/disassembler.m"
01684                                         
01685 
01686                                                 sprintf (str,  "BTSod", DIS_EADDR32, DIS_REG32);
01687 
01688                                         
01689 
01690                                         
01691                                         
01692                                         
01693                                       } /*opt-block*//*opt-block+*/
01694                                       else 
01695                                         goto MATCH_label_a78;  /*opt-block+*/
01696                                       
01697                                       break;
01698                                     case 2: 
01699                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
01700                                       if ((MATCH_w_8_16 & 0x7) 
01701                                               /* r_m at 16 */ == 4 && 
01702                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01703                                               /* index at 24 */ && 
01704                                         (MATCH_w_8_24 >> 3 & 0x7) 
01705                                               /* index at 24 */ < 8)) 
01706                                         goto MATCH_label_a79;  /*opt-block+*/
01707                                       else 
01708                                         goto MATCH_label_a80;  /*opt-block+*/
01709                                       
01710                                       break;
01711                                     case 3: 
01712                                       goto MATCH_label_a77; break;
01713                                     default: assert(0);
01714                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
01715                                         -- mod at 16 --*/ 
01716                                 
01717                               } /*opt-block*/
01718                               else { 
01719                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
01720                                 
01721                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
01722                                         /* mod at 16 */) {
01723                                     case 0: 
01724                                       
01725                                         switch((MATCH_w_8_16 & 0x7) 
01726                                               /* r_m at 16 */) {
01727                                           case 0: case 1: case 2: case 3: 
01728                                           case 6: case 7: 
01729                                             goto MATCH_label_a73; break;
01730                                           case 4: 
01731                                             MATCH_w_8_24 = 
01732                                               getByte(3 + MATCH_p); 
01733                                             if ((MATCH_w_8_24 & 0x7) 
01734                                                     /* base at 24 */ == 5 && 
01735                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01736                                                     /* index at 24 */ && 
01737                                               (MATCH_w_8_24 >> 3 & 0x7) 
01738                                                     /* index at 24 */ < 8)) 
01739                                               goto MATCH_label_a75;  /*opt-block+*/
01740                                             else 
01741                                               goto MATCH_label_a74;  /*opt-block+*/
01742                                             
01743                                             break;
01744                                           case 5: 
01745                                             goto MATCH_label_a76; break;
01746                                           default: assert(0);
01747                                         } /* (MATCH_w_8_16 & 0x7) 
01748                                               -- r_m at 16 --*/ 
01749                                       break;
01750                                     case 1: 
01751                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
01752                                       if ((MATCH_w_8_16 & 0x7) 
01753                                               /* r_m at 16 */ == 4 && 
01754                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01755                                               /* index at 24 */ && 
01756                                         (MATCH_w_8_24 >> 3 & 0x7) 
01757                                               /* index at 24 */ < 8)) { 
01758                                         unsigned Eaddr = 
01759                                           2 + addressToPC(MATCH_p);
01760                                         unsigned reg = 
01761                                           (MATCH_w_8_16 >> 3 & 0x7) 
01762                                                 /* reg_opcode at 16 */;
01763                                         nextPC = 5 + MATCH_p; 
01764                                         
01765                                         #line 1034 "machine/pentium/disassembler.m"
01766                                         
01767 
01768                                                 sprintf (str,  "BTod", DIS_EADDR32, DIS_REG32);
01769 
01770                                         
01771 
01772                                         
01773                                         
01774                                         
01775                                       } /*opt-block*//*opt-block+*/
01776                                       else 
01777                                         goto MATCH_label_a74;  /*opt-block+*/
01778                                       
01779                                       break;
01780                                     case 2: 
01781                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
01782                                       if ((MATCH_w_8_16 & 0x7) 
01783                                               /* r_m at 16 */ == 4 && 
01784                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01785                                               /* index at 24 */ && 
01786                                         (MATCH_w_8_24 >> 3 & 0x7) 
01787                                               /* index at 24 */ < 8)) 
01788                                         goto MATCH_label_a75;  /*opt-block+*/
01789                                       else 
01790                                         goto MATCH_label_a76;  /*opt-block+*/
01791                                       
01792                                       break;
01793                                     case 3: 
01794                                       goto MATCH_label_a73; break;
01795                                     default: assert(0);
01796                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
01797                                         -- mod at 16 --*/ 
01798                                 
01799                               } /*opt-block*/
01800                               break;
01801                             case 4: 
01802                               if ((MATCH_w_8_8 >> 3 & 0x1) 
01803                                       /* page at 8 */ == 1) { 
01804                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
01805                                 
01806                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
01807                                         /* mod at 16 */) {
01808                                     case 0: 
01809                                       
01810                                         switch((MATCH_w_8_16 & 0x7) 
01811                                               /* r_m at 16 */) {
01812                                           case 0: case 1: case 2: case 3: 
01813                                           case 6: case 7: 
01814                                             MATCH_w_8_24 = 
01815                                               getByte(3 + MATCH_p); 
01816                                             goto MATCH_label_a85; 
01817                                             
01818                                             break;
01819                                           case 4: 
01820                                             MATCH_w_8_24 = 
01821                                               getByte(3 + MATCH_p); 
01822                                             if ((MATCH_w_8_24 & 0x7) 
01823                                                     /* base at 24 */ == 5 && 
01824                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01825                                                     /* index at 24 */ && 
01826                                               (MATCH_w_8_24 >> 3 & 0x7) 
01827                                                     /* index at 24 */ < 8)) { 
01828                                               MATCH_w_8_64 = 
01829                                                 getByte(8 + MATCH_p); 
01830                                               goto MATCH_label_a87; 
01831                                               
01832                                             } /*opt-block*/
01833                                             else { 
01834                                               MATCH_w_8_32 = 
01835                                                 getByte(4 + MATCH_p); 
01836                                               goto MATCH_label_a86; 
01837                                               
01838                                             } /*opt-block*/
01839                                             
01840                                             break;
01841                                           case 5: 
01842                                             MATCH_w_8_56 = 
01843                                               getByte(7 + MATCH_p); 
01844                                             goto MATCH_label_a88; 
01845                                             
01846                                             break;
01847                                           default: assert(0);
01848                                         } /* (MATCH_w_8_16 & 0x7) 
01849                                               -- r_m at 16 --*/ 
01850                                       break;
01851                                     case 1: 
01852                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
01853                                       if ((MATCH_w_8_16 & 0x7) 
01854                                               /* r_m at 16 */ == 4 && 
01855                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01856                                               /* index at 24 */ && 
01857                                         (MATCH_w_8_24 >> 3 & 0x7) 
01858                                               /* index at 24 */ < 8)) { 
01859                                         MATCH_w_8_40 = getByte(5 + MATCH_p); 
01860                                         { 
01861                                           unsigned Eaddr = 
01862                                             2 + addressToPC(MATCH_p);
01863                                           unsigned count = 
01864                                             (MATCH_w_8_40 & 0xff) 
01865                                                   /* i8 at 40 */;
01866                                           unsigned reg = 
01867                                             (MATCH_w_8_16 >> 3 & 0x7) 
01868                                                   /* reg_opcode at 16 */;
01869                                           nextPC = 6 + MATCH_p; 
01870                                           
01871                                           #line 167 "machine/pentium/disassembler.m"
01872                                           
01873 
01874                                                   sprintf (str,  "SHRD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
01875 
01876                                           
01877 
01878                                           
01879                                           
01880                                           
01881                                         }
01882                                         
01883                                       } /*opt-block*/
01884                                       else { 
01885                                         MATCH_w_8_32 = getByte(4 + MATCH_p); 
01886                                         goto MATCH_label_a86; 
01887                                         
01888                                       } /*opt-block*/
01889                                       
01890                                       break;
01891                                     case 2: 
01892                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
01893                                       if ((MATCH_w_8_16 & 0x7) 
01894                                               /* r_m at 16 */ == 4 && 
01895                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01896                                               /* index at 24 */ && 
01897                                         (MATCH_w_8_24 >> 3 & 0x7) 
01898                                               /* index at 24 */ < 8)) { 
01899                                         MATCH_w_8_64 = getByte(8 + MATCH_p); 
01900                                         goto MATCH_label_a87; 
01901                                         
01902                                       } /*opt-block*/
01903                                       else { 
01904                                         MATCH_w_8_56 = getByte(7 + MATCH_p); 
01905                                         goto MATCH_label_a88; 
01906                                         
01907                                       } /*opt-block*/
01908                                       
01909                                       break;
01910                                     case 3: 
01911                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
01912                                       goto MATCH_label_a85; 
01913                                       
01914                                       break;
01915                                     default: assert(0);
01916                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
01917                                         -- mod at 16 --*/ 
01918                                 
01919                               } /*opt-block*/
01920                               else { 
01921                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
01922                                 
01923                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
01924                                         /* mod at 16 */) {
01925                                     case 0: 
01926                                       
01927                                         switch((MATCH_w_8_16 & 0x7) 
01928                                               /* r_m at 16 */) {
01929                                           case 0: case 1: case 2: case 3: 
01930                                           case 6: case 7: 
01931                                             MATCH_w_8_24 = 
01932                                               getByte(3 + MATCH_p); 
01933                                             goto MATCH_label_a81; 
01934                                             
01935                                             break;
01936                                           case 4: 
01937                                             MATCH_w_8_24 = 
01938                                               getByte(3 + MATCH_p); 
01939                                             if ((MATCH_w_8_24 & 0x7) 
01940                                                     /* base at 24 */ == 5 && 
01941                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01942                                                     /* index at 24 */ && 
01943                                               (MATCH_w_8_24 >> 3 & 0x7) 
01944                                                     /* index at 24 */ < 8)) { 
01945                                               MATCH_w_8_64 = 
01946                                                 getByte(8 + MATCH_p); 
01947                                               goto MATCH_label_a83; 
01948                                               
01949                                             } /*opt-block*/
01950                                             else { 
01951                                               MATCH_w_8_32 = 
01952                                                 getByte(4 + MATCH_p); 
01953                                               goto MATCH_label_a82; 
01954                                               
01955                                             } /*opt-block*/
01956                                             
01957                                             break;
01958                                           case 5: 
01959                                             MATCH_w_8_56 = 
01960                                               getByte(7 + MATCH_p); 
01961                                             goto MATCH_label_a84; 
01962                                             
01963                                             break;
01964                                           default: assert(0);
01965                                         } /* (MATCH_w_8_16 & 0x7) 
01966                                               -- r_m at 16 --*/ 
01967                                       break;
01968                                     case 1: 
01969                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
01970                                       if ((MATCH_w_8_16 & 0x7) 
01971                                               /* r_m at 16 */ == 4 && 
01972                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
01973                                               /* index at 24 */ && 
01974                                         (MATCH_w_8_24 >> 3 & 0x7) 
01975                                               /* index at 24 */ < 8)) { 
01976                                         MATCH_w_8_40 = getByte(5 + MATCH_p); 
01977                                         { 
01978                                           unsigned Eaddr = 
01979                                             2 + addressToPC(MATCH_p);
01980                                           unsigned count = 
01981                                             (MATCH_w_8_40 & 0xff) 
01982                                                   /* i8 at 40 */;
01983                                           unsigned reg = 
01984                                             (MATCH_w_8_16 >> 3 & 0x7) 
01985                                                   /* reg_opcode at 16 */;
01986                                           nextPC = 6 + MATCH_p; 
01987                                           
01988                                           #line 161 "machine/pentium/disassembler.m"
01989                                           
01990 
01991                                                   sprintf (str,  "SHLD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
01992 
01993                                           
01994 
01995                                           
01996                                           
01997                                           
01998                                         }
01999                                         
02000                                       } /*opt-block*/
02001                                       else { 
02002                                         MATCH_w_8_32 = getByte(4 + MATCH_p); 
02003                                         goto MATCH_label_a82; 
02004                                         
02005                                       } /*opt-block*/
02006                                       
02007                                       break;
02008                                     case 2: 
02009                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02010                                       if ((MATCH_w_8_16 & 0x7) 
02011                                               /* r_m at 16 */ == 4 && 
02012                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02013                                               /* index at 24 */ && 
02014                                         (MATCH_w_8_24 >> 3 & 0x7) 
02015                                               /* index at 24 */ < 8)) { 
02016                                         MATCH_w_8_64 = getByte(8 + MATCH_p); 
02017                                         goto MATCH_label_a83; 
02018                                         
02019                                       } /*opt-block*/
02020                                       else { 
02021                                         MATCH_w_8_56 = getByte(7 + MATCH_p); 
02022                                         goto MATCH_label_a84; 
02023                                         
02024                                       } /*opt-block*/
02025                                       
02026                                       break;
02027                                     case 3: 
02028                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02029                                       goto MATCH_label_a81; 
02030                                       
02031                                       break;
02032                                     default: assert(0);
02033                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
02034                                         -- mod at 16 --*/ 
02035                                 
02036                               } /*opt-block*/
02037                               break;
02038                             case 5: 
02039                               if ((MATCH_w_8_8 >> 3 & 0x1) 
02040                                       /* page at 8 */ == 1) { 
02041                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
02042                                 
02043                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
02044                                         /* mod at 16 */) {
02045                                     case 0: 
02046                                       
02047                                         switch((MATCH_w_8_16 & 0x7) 
02048                                               /* r_m at 16 */) {
02049                                           case 0: case 1: case 2: case 3: 
02050                                           case 6: case 7: 
02051                                             goto MATCH_label_a93; break;
02052                                           case 4: 
02053                                             MATCH_w_8_24 = 
02054                                               getByte(3 + MATCH_p); 
02055                                             if ((MATCH_w_8_24 & 0x7) 
02056                                                     /* base at 24 */ == 5 && 
02057                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02058                                                     /* index at 24 */ && 
02059                                               (MATCH_w_8_24 >> 3 & 0x7) 
02060                                                     /* index at 24 */ < 8)) 
02061                                               goto MATCH_label_a95;  /*opt-block+*/
02062                                             else 
02063                                               goto MATCH_label_a94;  /*opt-block+*/
02064                                             
02065                                             break;
02066                                           case 5: 
02067                                             goto MATCH_label_a96; break;
02068                                           default: assert(0);
02069                                         } /* (MATCH_w_8_16 & 0x7) 
02070                                               -- r_m at 16 --*/ 
02071                                       break;
02072                                     case 1: 
02073                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02074                                       if ((MATCH_w_8_16 & 0x7) 
02075                                               /* r_m at 16 */ == 4 && 
02076                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02077                                               /* index at 24 */ && 
02078                                         (MATCH_w_8_24 >> 3 & 0x7) 
02079                                               /* index at 24 */ < 8)) { 
02080                                         unsigned Eaddr = 
02081                                           2 + addressToPC(MATCH_p);
02082                                         unsigned reg = 
02083                                           (MATCH_w_8_16 >> 3 & 0x7) 
02084                                                 /* reg_opcode at 16 */;
02085                                         nextPC = 5 + MATCH_p; 
02086                                         
02087                                         #line 155 "machine/pentium/disassembler.m"
02088                                         
02089 
02090                                                 sprintf (str,  "SHRD.CLod", DIS_EADDR32, DIS_REG32);
02091 
02092                                         
02093 
02094                                         
02095                                         
02096                                         
02097                                       } /*opt-block*//*opt-block+*/
02098                                       else 
02099                                         goto MATCH_label_a94;  /*opt-block+*/
02100                                       
02101                                       break;
02102                                     case 2: 
02103                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02104                                       if ((MATCH_w_8_16 & 0x7) 
02105                                               /* r_m at 16 */ == 4 && 
02106                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02107                                               /* index at 24 */ && 
02108                                         (MATCH_w_8_24 >> 3 & 0x7) 
02109                                               /* index at 24 */ < 8)) 
02110                                         goto MATCH_label_a95;  /*opt-block+*/
02111                                       else 
02112                                         goto MATCH_label_a96;  /*opt-block+*/
02113                                       
02114                                       break;
02115                                     case 3: 
02116                                       goto MATCH_label_a93; break;
02117                                     default: assert(0);
02118                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
02119                                         -- mod at 16 --*/ 
02120                                 
02121                               } /*opt-block*/
02122                               else { 
02123                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
02124                                 
02125                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
02126                                         /* mod at 16 */) {
02127                                     case 0: 
02128                                       
02129                                         switch((MATCH_w_8_16 & 0x7) 
02130                                               /* r_m at 16 */) {
02131                                           case 0: case 1: case 2: case 3: 
02132                                           case 6: case 7: 
02133                                             goto MATCH_label_a89; break;
02134                                           case 4: 
02135                                             MATCH_w_8_24 = 
02136                                               getByte(3 + MATCH_p); 
02137                                             if ((MATCH_w_8_24 & 0x7) 
02138                                                     /* base at 24 */ == 5 && 
02139                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02140                                                     /* index at 24 */ && 
02141                                               (MATCH_w_8_24 >> 3 & 0x7) 
02142                                                     /* index at 24 */ < 8)) 
02143                                               goto MATCH_label_a91;  /*opt-block+*/
02144                                             else 
02145                                               goto MATCH_label_a90;  /*opt-block+*/
02146                                             
02147                                             break;
02148                                           case 5: 
02149                                             goto MATCH_label_a92; break;
02150                                           default: assert(0);
02151                                         } /* (MATCH_w_8_16 & 0x7) 
02152                                               -- r_m at 16 --*/ 
02153                                       break;
02154                                     case 1: 
02155                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02156                                       if ((MATCH_w_8_16 & 0x7) 
02157                                               /* r_m at 16 */ == 4 && 
02158                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02159                                               /* index at 24 */ && 
02160                                         (MATCH_w_8_24 >> 3 & 0x7) 
02161                                               /* index at 24 */ < 8)) { 
02162                                         unsigned Eaddr = 
02163                                           2 + addressToPC(MATCH_p);
02164                                         unsigned reg = 
02165                                           (MATCH_w_8_16 >> 3 & 0x7) 
02166                                                 /* reg_opcode at 16 */;
02167                                         nextPC = 5 + MATCH_p; 
02168                                         
02169                                         #line 149 "machine/pentium/disassembler.m"
02170                                         
02171 
02172                                                 sprintf (str,  "SHLD.CLod", DIS_EADDR32, DIS_REG32);
02173 
02174                                         
02175 
02176                                         
02177                                         
02178                                         
02179                                       } /*opt-block*//*opt-block+*/
02180                                       else 
02181                                         goto MATCH_label_a90;  /*opt-block+*/
02182                                       
02183                                       break;
02184                                     case 2: 
02185                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02186                                       if ((MATCH_w_8_16 & 0x7) 
02187                                               /* r_m at 16 */ == 4 && 
02188                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02189                                               /* index at 24 */ && 
02190                                         (MATCH_w_8_24 >> 3 & 0x7) 
02191                                               /* index at 24 */ < 8)) 
02192                                         goto MATCH_label_a91;  /*opt-block+*/
02193                                       else 
02194                                         goto MATCH_label_a92;  /*opt-block+*/
02195                                       
02196                                       break;
02197                                     case 3: 
02198                                       goto MATCH_label_a89; break;
02199                                     default: assert(0);
02200                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
02201                                         -- mod at 16 --*/ 
02202                                 
02203                               } /*opt-block*/
02204                               break;
02205                             case 6: 
02206                               goto MATCH_label_a39; break;
02207                             case 7: 
02208                               if ((MATCH_w_8_8 >> 3 & 0x1) 
02209                                       /* page at 8 */ == 1) { 
02210                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
02211                                 
02212                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
02213                                         /* mod at 16 */) {
02214                                     case 0: 
02215                                       
02216                                         switch((MATCH_w_8_16 & 0x7) 
02217                                               /* r_m at 16 */) {
02218                                           case 0: case 1: case 2: case 3: 
02219                                           case 6: case 7: 
02220                                             goto MATCH_label_a97; break;
02221                                           case 4: 
02222                                             MATCH_w_8_24 = 
02223                                               getByte(3 + MATCH_p); 
02224                                             if ((MATCH_w_8_24 & 0x7) 
02225                                                     /* base at 24 */ == 5 && 
02226                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02227                                                     /* index at 24 */ && 
02228                                               (MATCH_w_8_24 >> 3 & 0x7) 
02229                                                     /* index at 24 */ < 8)) 
02230                                               goto MATCH_label_a99;  /*opt-block+*/
02231                                             else 
02232                                               goto MATCH_label_a98;  /*opt-block+*/
02233                                             
02234                                             break;
02235                                           case 5: 
02236                                             goto MATCH_label_a100; break;
02237                                           default: assert(0);
02238                                         } /* (MATCH_w_8_16 & 0x7) 
02239                                               -- r_m at 16 --*/ 
02240                                       break;
02241                                     case 1: 
02242                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02243                                       if ((MATCH_w_8_16 & 0x7) 
02244                                               /* r_m at 16 */ == 4 && 
02245                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02246                                               /* index at 24 */ && 
02247                                         (MATCH_w_8_24 >> 3 & 0x7) 
02248                                               /* index at 24 */ < 8)) { 
02249                                         unsigned Eaddr = 
02250                                           2 + addressToPC(MATCH_p);
02251                                         unsigned reg = 
02252                                           (MATCH_w_8_16 >> 3 & 0x7) 
02253                                                 /* reg_opcode at 16 */;
02254                                         nextPC = 5 + MATCH_p; 
02255                                         
02256                                         #line 869 "machine/pentium/disassembler.m"
02257                                         
02258 
02259                                                 sprintf (str,  "IMULrmod", DIS_REG32, DIS_EADDR32);
02260 
02261                                         
02262 
02263                                         
02264                                         
02265                                         
02266                                       } /*opt-block*//*opt-block+*/
02267                                       else 
02268                                         goto MATCH_label_a98;  /*opt-block+*/
02269                                       
02270                                       break;
02271                                     case 2: 
02272                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02273                                       if ((MATCH_w_8_16 & 0x7) 
02274                                               /* r_m at 16 */ == 4 && 
02275                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02276                                               /* index at 24 */ && 
02277                                         (MATCH_w_8_24 >> 3 & 0x7) 
02278                                               /* index at 24 */ < 8)) 
02279                                         goto MATCH_label_a99;  /*opt-block+*/
02280                                       else 
02281                                         goto MATCH_label_a100;  /*opt-block+*/
02282                                       
02283                                       break;
02284                                     case 3: 
02285                                       goto MATCH_label_a97; break;
02286                                     default: assert(0);
02287                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
02288                                         -- mod at 16 --*/ 
02289                                 
02290                               } /*opt-block*/
02291                               else 
02292                                 goto MATCH_label_a39;  /*opt-block+*/
02293                               break;
02294                             default: assert(0);
02295                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
02296                         break;
02297                       case 11: 
02298                         if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) 
02299                           
02300                             switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
02301                               case 0: case 1: 
02302                                 goto MATCH_label_a39; break;
02303                               case 2: 
02304                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
02305                                 
02306                                   switch((MATCH_w_8_16 >> 3 & 0x7) 
02307                                         /* reg_opcode at 16 */) {
02308                                     case 0: case 1: case 2: case 3: 
02309                                       goto MATCH_label_a39; break;
02310                                     case 4: 
02311                                       
02312                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
02313                                               /* mod at 16 */) {
02314                                           case 0: 
02315                                             
02316                                               switch((MATCH_w_8_16 & 0x7) 
02317                                                     /* r_m at 16 */) {
02318                                                 case 0: case 1: case 2: 
02319                                                 case 3: case 6: case 7: 
02320                                                   MATCH_w_8_24 = 
02321                                                     getByte(3 + MATCH_p); 
02322                                                   goto MATCH_label_a130; 
02323                                                   
02324                                                   break;
02325                                                 case 4: 
02326                                                   MATCH_w_8_24 = 
02327                                                     getByte(3 + MATCH_p); 
02328                                                   if ((MATCH_w_8_24 & 0x7) 
02329                                                           /* base at 24 */ == 5 && 
02330                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02331                                                           /* index at 24 */ && 
02332                                                     (MATCH_w_8_24 >> 3 & 0x7) 
02333                                                           /* index at 24 */ < 8)) { 
02334                                                     MATCH_w_8_64 = 
02335                                                       getByte(8 + MATCH_p); 
02336                                                     goto MATCH_label_a132; 
02337                                                     
02338                                                   } /*opt-block*/
02339                                                   else { 
02340                                                     MATCH_w_8_32 = 
02341                                                       getByte(4 + MATCH_p); 
02342                                                     goto MATCH_label_a131; 
02343                                                     
02344                                                   } /*opt-block*/
02345                                                   
02346                                                   break;
02347                                                 case 5: 
02348                                                   MATCH_w_8_56 = 
02349                                                     getByte(7 + MATCH_p); 
02350                                                   goto MATCH_label_a133; 
02351                                                   
02352                                                   break;
02353                                                 default: assert(0);
02354                                               } /* (MATCH_w_8_16 & 0x7) 
02355                                                     -- r_m at 16 --*/ 
02356                                             break;
02357                                           case 1: 
02358                                             MATCH_w_8_24 = 
02359                                               getByte(3 + MATCH_p); 
02360                                             if ((MATCH_w_8_16 & 0x7) 
02361                                                     /* r_m at 16 */ == 4 && 
02362                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02363                                                     /* index at 24 */ && 
02364                                               (MATCH_w_8_24 >> 3 & 0x7) 
02365                                                     /* index at 24 */ < 8)) { 
02366                                               MATCH_w_8_40 = 
02367                                                 getByte(5 + MATCH_p); 
02368                                               { 
02369                                                 unsigned Eaddr = 
02370                                                   2 + addressToPC(MATCH_p);
02371                                                 int /* [~128..127] */ i8 = 
02372                                                   sign_extend(
02373                                                               (MATCH_w_8_40 & 0xff) 
02374                                                                     /* i8 at 40 */, 
02375                                                               8);
02376                                                 nextPC = 6 + MATCH_p; 
02377                                                 
02378                                                 #line 1028 "machine/pentium/disassembler.m"
02379                                                 
02380 
02381                                                         sprintf (str,  "BTiod", DIS_EADDR32, DIS_I8);
02382 
02383                                                 
02384 
02385                                                 
02386                                                 
02387                                                 
02388                                               }
02389                                               
02390                                             } /*opt-block*/
02391                                             else { 
02392                                               MATCH_w_8_32 = 
02393                                                 getByte(4 + MATCH_p); 
02394                                               goto MATCH_label_a131; 
02395                                               
02396                                             } /*opt-block*/
02397                                             
02398                                             break;
02399                                           case 2: 
02400                                             MATCH_w_8_24 = 
02401                                               getByte(3 + MATCH_p); 
02402                                             if ((MATCH_w_8_16 & 0x7) 
02403                                                     /* r_m at 16 */ == 4 && 
02404                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02405                                                     /* index at 24 */ && 
02406                                               (MATCH_w_8_24 >> 3 & 0x7) 
02407                                                     /* index at 24 */ < 8)) { 
02408                                               MATCH_w_8_64 = 
02409                                                 getByte(8 + MATCH_p); 
02410                                               goto MATCH_label_a132; 
02411                                               
02412                                             } /*opt-block*/
02413                                             else { 
02414                                               MATCH_w_8_56 = 
02415                                                 getByte(7 + MATCH_p); 
02416                                               goto MATCH_label_a133; 
02417                                               
02418                                             } /*opt-block*/
02419                                             
02420                                             break;
02421                                           case 3: 
02422                                             MATCH_w_8_24 = 
02423                                               getByte(3 + MATCH_p); 
02424                                             goto MATCH_label_a130; 
02425                                             
02426                                             break;
02427                                           default: assert(0);
02428                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
02429                                               -- mod at 16 --*/ 
02430                                       break;
02431                                     case 5: 
02432                                       
02433                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
02434                                               /* mod at 16 */) {
02435                                           case 0: 
02436                                             
02437                                               switch((MATCH_w_8_16 & 0x7) 
02438                                                     /* r_m at 16 */) {
02439                                                 case 0: case 1: case 2: 
02440                                                 case 3: case 6: case 7: 
02441                                                   MATCH_w_8_24 = 
02442                                                     getByte(3 + MATCH_p); 
02443                                                   goto MATCH_label_a134; 
02444                                                   
02445                                                   break;
02446                                                 case 4: 
02447                                                   MATCH_w_8_24 = 
02448                                                     getByte(3 + MATCH_p); 
02449                                                   if ((MATCH_w_8_24 & 0x7) 
02450                                                           /* base at 24 */ == 5 && 
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_w_8_64 = 
02456                                                       getByte(8 + MATCH_p); 
02457                                                     goto MATCH_label_a136; 
02458                                                     
02459                                                   } /*opt-block*/
02460                                                   else { 
02461                                                     MATCH_w_8_32 = 
02462                                                       getByte(4 + MATCH_p); 
02463                                                     goto MATCH_label_a135; 
02464                                                     
02465                                                   } /*opt-block*/
02466                                                   
02467                                                   break;
02468                                                 case 5: 
02469                                                   MATCH_w_8_56 = 
02470                                                     getByte(7 + MATCH_p); 
02471                                                   goto MATCH_label_a137; 
02472                                                   
02473                                                   break;
02474                                                 default: assert(0);
02475                                               } /* (MATCH_w_8_16 & 0x7) 
02476                                                     -- r_m at 16 --*/ 
02477                                             break;
02478                                           case 1: 
02479                                             MATCH_w_8_24 = 
02480                                               getByte(3 + MATCH_p); 
02481                                             if ((MATCH_w_8_16 & 0x7) 
02482                                                     /* r_m at 16 */ == 4 && 
02483                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02484                                                     /* index at 24 */ && 
02485                                               (MATCH_w_8_24 >> 3 & 0x7) 
02486                                                     /* index at 24 */ < 8)) { 
02487                                               MATCH_w_8_40 = 
02488                                                 getByte(5 + MATCH_p); 
02489                                               { 
02490                                                 unsigned Eaddr = 
02491                                                   2 + addressToPC(MATCH_p);
02492                                                 int /* [~128..127] */ i8 = 
02493                                                   sign_extend(
02494                                                               (MATCH_w_8_40 & 0xff) 
02495                                                                     /* i8 at 40 */, 
02496                                                               8);
02497                                                 nextPC = 6 + MATCH_p; 
02498                                                 
02499                                                 #line 992 "machine/pentium/disassembler.m"
02500                                                 
02501 
02502                                                         sprintf (str,  "BTSiod", DIS_I8, DIS_EADDR32);
02503 
02504                                                 
02505 
02506                                                 
02507                                                 
02508                                                 
02509                                               }
02510                                               
02511                                             } /*opt-block*/
02512                                             else { 
02513                                               MATCH_w_8_32 = 
02514                                                 getByte(4 + MATCH_p); 
02515                                               goto MATCH_label_a135; 
02516                                               
02517                                             } /*opt-block*/
02518                                             
02519                                             break;
02520                                           case 2: 
02521                                             MATCH_w_8_24 = 
02522                                               getByte(3 + MATCH_p); 
02523                                             if ((MATCH_w_8_16 & 0x7) 
02524                                                     /* r_m at 16 */ == 4 && 
02525                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02526                                                     /* index at 24 */ && 
02527                                               (MATCH_w_8_24 >> 3 & 0x7) 
02528                                                     /* index at 24 */ < 8)) { 
02529                                               MATCH_w_8_64 = 
02530                                                 getByte(8 + MATCH_p); 
02531                                               goto MATCH_label_a136; 
02532                                               
02533                                             } /*opt-block*/
02534                                             else { 
02535                                               MATCH_w_8_56 = 
02536                                                 getByte(7 + MATCH_p); 
02537                                               goto MATCH_label_a137; 
02538                                               
02539                                             } /*opt-block*/
02540                                             
02541                                             break;
02542                                           case 3: 
02543                                             MATCH_w_8_24 = 
02544                                               getByte(3 + MATCH_p); 
02545                                             goto MATCH_label_a134; 
02546                                             
02547                                             break;
02548                                           default: assert(0);
02549                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
02550                                               -- mod at 16 --*/ 
02551                                       break;
02552                                     case 6: 
02553                                       
02554                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
02555                                               /* mod at 16 */) {
02556                                           case 0: 
02557                                             
02558                                               switch((MATCH_w_8_16 & 0x7) 
02559                                                     /* r_m at 16 */) {
02560                                                 case 0: case 1: case 2: 
02561                                                 case 3: case 6: case 7: 
02562                                                   MATCH_w_8_24 = 
02563                                                     getByte(3 + MATCH_p); 
02564                                                   goto MATCH_label_a138; 
02565                                                   
02566                                                   break;
02567                                                 case 4: 
02568                                                   MATCH_w_8_24 = 
02569                                                     getByte(3 + MATCH_p); 
02570                                                   if ((MATCH_w_8_24 & 0x7) 
02571                                                           /* base at 24 */ == 5 && 
02572                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02573                                                           /* index at 24 */ && 
02574                                                     (MATCH_w_8_24 >> 3 & 0x7) 
02575                                                           /* index at 24 */ < 8)) { 
02576                                                     MATCH_w_8_64 = 
02577                                                       getByte(8 + MATCH_p); 
02578                                                     goto MATCH_label_a140; 
02579                                                     
02580                                                   } /*opt-block*/
02581                                                   else { 
02582                                                     MATCH_w_8_32 = 
02583                                                       getByte(4 + MATCH_p); 
02584                                                     goto MATCH_label_a139; 
02585                                                     
02586                                                   } /*opt-block*/
02587                                                   
02588                                                   break;
02589                                                 case 5: 
02590                                                   MATCH_w_8_56 = 
02591                                                     getByte(7 + MATCH_p); 
02592                                                   goto MATCH_label_a141; 
02593                                                   
02594                                                   break;
02595                                                 default: assert(0);
02596                                               } /* (MATCH_w_8_16 & 0x7) 
02597                                                     -- r_m at 16 --*/ 
02598                                             break;
02599                                           case 1: 
02600                                             MATCH_w_8_24 = 
02601                                               getByte(3 + MATCH_p); 
02602                                             if ((MATCH_w_8_16 & 0x7) 
02603                                                     /* r_m at 16 */ == 4 && 
02604                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02605                                                     /* index at 24 */ && 
02606                                               (MATCH_w_8_24 >> 3 & 0x7) 
02607                                                     /* index at 24 */ < 8)) { 
02608                                               MATCH_w_8_40 = 
02609                                                 getByte(5 + MATCH_p); 
02610                                               { 
02611                                                 unsigned Eaddr = 
02612                                                   2 + addressToPC(MATCH_p);
02613                                                 int /* [~128..127] */ i8 = 
02614                                                   sign_extend(
02615                                                               (MATCH_w_8_40 & 0xff) 
02616                                                                     /* i8 at 40 */, 
02617                                                               8);
02618                                                 nextPC = 6 + MATCH_p; 
02619                                                 
02620                                                 #line 1004 "machine/pentium/disassembler.m"
02621                                                 
02622 
02623                                                         sprintf (str,  "BTRiod", DIS_EADDR32, DIS_I8);
02624 
02625                                                 
02626 
02627                                                 
02628                                                 
02629                                                 
02630                                               }
02631                                               
02632                                             } /*opt-block*/
02633                                             else { 
02634                                               MATCH_w_8_32 = 
02635                                                 getByte(4 + MATCH_p); 
02636                                               goto MATCH_label_a139; 
02637                                               
02638                                             } /*opt-block*/
02639                                             
02640                                             break;
02641                                           case 2: 
02642                                             MATCH_w_8_24 = 
02643                                               getByte(3 + MATCH_p); 
02644                                             if ((MATCH_w_8_16 & 0x7) 
02645                                                     /* r_m at 16 */ == 4 && 
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_w_8_64 = 
02651                                                 getByte(8 + MATCH_p); 
02652                                               goto MATCH_label_a140; 
02653                                               
02654                                             } /*opt-block*/
02655                                             else { 
02656                                               MATCH_w_8_56 = 
02657                                                 getByte(7 + MATCH_p); 
02658                                               goto MATCH_label_a141; 
02659                                               
02660                                             } /*opt-block*/
02661                                             
02662                                             break;
02663                                           case 3: 
02664                                             MATCH_w_8_24 = 
02665                                               getByte(3 + MATCH_p); 
02666                                             goto MATCH_label_a138; 
02667                                             
02668                                             break;
02669                                           default: assert(0);
02670                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
02671                                               -- mod at 16 --*/ 
02672                                       break;
02673                                     case 7: 
02674                                       
02675                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
02676                                               /* mod at 16 */) {
02677                                           case 0: 
02678                                             
02679                                               switch((MATCH_w_8_16 & 0x7) 
02680                                                     /* r_m at 16 */) {
02681                                                 case 0: case 1: case 2: 
02682                                                 case 3: case 6: case 7: 
02683                                                   MATCH_w_8_24 = 
02684                                                     getByte(3 + MATCH_p); 
02685                                                   goto MATCH_label_a142; 
02686                                                   
02687                                                   break;
02688                                                 case 4: 
02689                                                   MATCH_w_8_24 = 
02690                                                     getByte(3 + MATCH_p); 
02691                                                   if ((MATCH_w_8_24 & 0x7) 
02692                                                           /* base at 24 */ == 5 && 
02693                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02694                                                           /* index at 24 */ && 
02695                                                     (MATCH_w_8_24 >> 3 & 0x7) 
02696                                                           /* index at 24 */ < 8)) { 
02697                                                     MATCH_w_8_64 = 
02698                                                       getByte(8 + MATCH_p); 
02699                                                     goto MATCH_label_a144; 
02700                                                     
02701                                                   } /*opt-block*/
02702                                                   else { 
02703                                                     MATCH_w_8_32 = 
02704                                                       getByte(4 + MATCH_p); 
02705                                                     goto MATCH_label_a143; 
02706                                                     
02707                                                   } /*opt-block*/
02708                                                   
02709                                                   break;
02710                                                 case 5: 
02711                                                   MATCH_w_8_56 = 
02712                                                     getByte(7 + MATCH_p); 
02713                                                   goto MATCH_label_a145; 
02714                                                   
02715                                                   break;
02716                                                 default: assert(0);
02717                                               } /* (MATCH_w_8_16 & 0x7) 
02718                                                     -- r_m at 16 --*/ 
02719                                             break;
02720                                           case 1: 
02721                                             MATCH_w_8_24 = 
02722                                               getByte(3 + MATCH_p); 
02723                                             if ((MATCH_w_8_16 & 0x7) 
02724                                                     /* r_m at 16 */ == 4 && 
02725                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02726                                                     /* index at 24 */ && 
02727                                               (MATCH_w_8_24 >> 3 & 0x7) 
02728                                                     /* index at 24 */ < 8)) { 
02729                                               MATCH_w_8_40 = 
02730                                                 getByte(5 + MATCH_p); 
02731                                               { 
02732                                                 unsigned Eaddr = 
02733                                                   2 + addressToPC(MATCH_p);
02734                                                 int /* [~128..127] */ i8 = 
02735                                                   sign_extend(
02736                                                               (MATCH_w_8_40 & 0xff) 
02737                                                                     /* i8 at 40 */, 
02738                                                               8);
02739                                                 nextPC = 6 + MATCH_p; 
02740                                                 
02741                                                 #line 1016 "machine/pentium/disassembler.m"
02742                                                 
02743 
02744                                                         sprintf (str,  "BTCiod", DIS_EADDR32, DIS_I8);
02745 
02746                                                 
02747 
02748                                                 
02749                                                 
02750                                                 
02751                                               }
02752                                               
02753                                             } /*opt-block*/
02754                                             else { 
02755                                               MATCH_w_8_32 = 
02756                                                 getByte(4 + MATCH_p); 
02757                                               goto MATCH_label_a143; 
02758                                               
02759                                             } /*opt-block*/
02760                                             
02761                                             break;
02762                                           case 2: 
02763                                             MATCH_w_8_24 = 
02764                                               getByte(3 + MATCH_p); 
02765                                             if ((MATCH_w_8_16 & 0x7) 
02766                                                     /* r_m at 16 */ == 4 && 
02767                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02768                                                     /* index at 24 */ && 
02769                                               (MATCH_w_8_24 >> 3 & 0x7) 
02770                                                     /* index at 24 */ < 8)) { 
02771                                               MATCH_w_8_64 = 
02772                                                 getByte(8 + MATCH_p); 
02773                                               goto MATCH_label_a144; 
02774                                               
02775                                             } /*opt-block*/
02776                                             else { 
02777                                               MATCH_w_8_56 = 
02778                                                 getByte(7 + MATCH_p); 
02779                                               goto MATCH_label_a145; 
02780                                               
02781                                             } /*opt-block*/
02782                                             
02783                                             break;
02784                                           case 3: 
02785                                             MATCH_w_8_24 = 
02786                                               getByte(3 + MATCH_p); 
02787                                             goto MATCH_label_a142; 
02788                                             
02789                                             break;
02790                                           default: assert(0);
02791                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
02792                                               -- mod at 16 --*/ 
02793                                       break;
02794                                     default: assert(0);
02795                                   } /* (MATCH_w_8_16 >> 3 & 0x7) 
02796                                         -- reg_opcode at 16 --*/ 
02797                                 
02798                                 break;
02799                               case 3: 
02800                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
02801                                 
02802                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
02803                                         /* mod at 16 */) {
02804                                     case 0: 
02805                                       
02806                                         switch((MATCH_w_8_16 & 0x7) 
02807                                               /* r_m at 16 */) {
02808                                           case 0: case 1: case 2: case 3: 
02809                                           case 6: case 7: 
02810                                             goto MATCH_label_a146; break;
02811                                           case 4: 
02812                                             MATCH_w_8_24 = 
02813                                               getByte(3 + MATCH_p); 
02814                                             if ((MATCH_w_8_24 & 0x7) 
02815                                                     /* base at 24 */ == 5 && 
02816                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02817                                                     /* index at 24 */ && 
02818                                               (MATCH_w_8_24 >> 3 & 0x7) 
02819                                                     /* index at 24 */ < 8)) 
02820                                               goto MATCH_label_a148;  /*opt-block+*/
02821                                             else 
02822                                               goto MATCH_label_a147;  /*opt-block+*/
02823                                             
02824                                             break;
02825                                           case 5: 
02826                                             goto MATCH_label_a149; break;
02827                                           default: assert(0);
02828                                         } /* (MATCH_w_8_16 & 0x7) 
02829                                               -- r_m at 16 --*/ 
02830                                       break;
02831                                     case 1: 
02832                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02833                                       if ((MATCH_w_8_16 & 0x7) 
02834                                               /* r_m at 16 */ == 4 && 
02835                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02836                                               /* index at 24 */ && 
02837                                         (MATCH_w_8_24 >> 3 & 0x7) 
02838                                               /* index at 24 */ < 8)) { 
02839                                         unsigned Eaddr = 
02840                                           2 + addressToPC(MATCH_p);
02841                                         unsigned reg = 
02842                                           (MATCH_w_8_16 >> 3 & 0x7) 
02843                                                 /* reg_opcode at 16 */;
02844                                         nextPC = 5 + MATCH_p; 
02845                                         
02846                                         #line 1022 "machine/pentium/disassembler.m"
02847                                         
02848 
02849                                                 sprintf (str,  "BTCod", DIS_EADDR32, DIS_REG32);
02850 
02851                                         
02852 
02853                                         
02854                                         
02855                                         
02856                                       } /*opt-block*//*opt-block+*/
02857                                       else 
02858                                         goto MATCH_label_a147;  /*opt-block+*/
02859                                       
02860                                       break;
02861                                     case 2: 
02862                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02863                                       if ((MATCH_w_8_16 & 0x7) 
02864                                               /* r_m at 16 */ == 4 && 
02865                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02866                                               /* index at 24 */ && 
02867                                         (MATCH_w_8_24 >> 3 & 0x7) 
02868                                               /* index at 24 */ < 8)) 
02869                                         goto MATCH_label_a148;  /*opt-block+*/
02870                                       else 
02871                                         goto MATCH_label_a149;  /*opt-block+*/
02872                                       
02873                                       break;
02874                                     case 3: 
02875                                       goto MATCH_label_a146; break;
02876                                     default: assert(0);
02877                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
02878                                         -- mod at 16 --*/ 
02879                                 
02880                                 break;
02881                               case 4: 
02882                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
02883                                 
02884                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
02885                                         /* mod at 16 */) {
02886                                     case 0: 
02887                                       
02888                                         switch((MATCH_w_8_16 & 0x7) 
02889                                               /* r_m at 16 */) {
02890                                           case 0: case 1: case 2: case 3: 
02891                                           case 6: case 7: 
02892                                             goto MATCH_label_a150; break;
02893                                           case 4: 
02894                                             MATCH_w_8_24 = 
02895                                               getByte(3 + MATCH_p); 
02896                                             if ((MATCH_w_8_24 & 0x7) 
02897                                                     /* base at 24 */ == 5 && 
02898                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02899                                                     /* index at 24 */ && 
02900                                               (MATCH_w_8_24 >> 3 & 0x7) 
02901                                                     /* index at 24 */ < 8)) 
02902                                               goto MATCH_label_a152;  /*opt-block+*/
02903                                             else 
02904                                               goto MATCH_label_a151;  /*opt-block+*/
02905                                             
02906                                             break;
02907                                           case 5: 
02908                                             goto MATCH_label_a153; break;
02909                                           default: assert(0);
02910                                         } /* (MATCH_w_8_16 & 0x7) 
02911                                               -- r_m at 16 --*/ 
02912                                       break;
02913                                     case 1: 
02914                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02915                                       if ((MATCH_w_8_16 & 0x7) 
02916                                               /* r_m at 16 */ == 4 && 
02917                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02918                                               /* index at 24 */ && 
02919                                         (MATCH_w_8_24 >> 3 & 0x7) 
02920                                               /* index at 24 */ < 8)) { 
02921                                         unsigned Eaddr = 
02922                                           2 + addressToPC(MATCH_p);
02923                                         unsigned reg = 
02924                                           (MATCH_w_8_16 >> 3 & 0x7) 
02925                                                 /* reg_opcode at 16 */;
02926                                         nextPC = 5 + MATCH_p; 
02927                                         
02928                                         #line 1049 "machine/pentium/disassembler.m"
02929                                         
02930 
02931                                                 sprintf (str,  "BSFod", DIS_REG32, DIS_EADDR32);
02932 
02933                                         
02934 
02935                                         
02936                                         
02937                                         
02938                                       } /*opt-block*//*opt-block+*/
02939                                       else 
02940                                         goto MATCH_label_a151;  /*opt-block+*/
02941                                       
02942                                       break;
02943                                     case 2: 
02944                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02945                                       if ((MATCH_w_8_16 & 0x7) 
02946                                               /* r_m at 16 */ == 4 && 
02947                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02948                                               /* index at 24 */ && 
02949                                         (MATCH_w_8_24 >> 3 & 0x7) 
02950                                               /* index at 24 */ < 8)) 
02951                                         goto MATCH_label_a152;  /*opt-block+*/
02952                                       else 
02953                                         goto MATCH_label_a153;  /*opt-block+*/
02954                                       
02955                                       break;
02956                                     case 3: 
02957                                       goto MATCH_label_a150; break;
02958                                     default: assert(0);
02959                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
02960                                         -- mod at 16 --*/ 
02961                                 
02962                                 break;
02963                               case 5: 
02964                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
02965                                 
02966                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
02967                                         /* mod at 16 */) {
02968                                     case 0: 
02969                                       
02970                                         switch((MATCH_w_8_16 & 0x7) 
02971                                               /* r_m at 16 */) {
02972                                           case 0: case 1: case 2: case 3: 
02973                                           case 6: case 7: 
02974                                             goto MATCH_label_a154; break;
02975                                           case 4: 
02976                                             MATCH_w_8_24 = 
02977                                               getByte(3 + MATCH_p); 
02978                                             if ((MATCH_w_8_24 & 0x7) 
02979                                                     /* base at 24 */ == 5 && 
02980                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
02981                                                     /* index at 24 */ && 
02982                                               (MATCH_w_8_24 >> 3 & 0x7) 
02983                                                     /* index at 24 */ < 8)) 
02984                                               goto MATCH_label_a156;  /*opt-block+*/
02985                                             else 
02986                                               goto MATCH_label_a155;  /*opt-block+*/
02987                                             
02988                                             break;
02989                                           case 5: 
02990                                             goto MATCH_label_a157; break;
02991                                           default: assert(0);
02992                                         } /* (MATCH_w_8_16 & 0x7) 
02993                                               -- r_m at 16 --*/ 
02994                                       break;
02995                                     case 1: 
02996                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
02997                                       if ((MATCH_w_8_16 & 0x7) 
02998                                               /* r_m at 16 */ == 4 && 
02999                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03000                                               /* index at 24 */ && 
03001                                         (MATCH_w_8_24 >> 3 & 0x7) 
03002                                               /* index at 24 */ < 8)) { 
03003                                         unsigned Eaddr = 
03004                                           2 + addressToPC(MATCH_p);
03005                                         unsigned reg = 
03006                                           (MATCH_w_8_16 >> 3 & 0x7) 
03007                                                 /* reg_opcode at 16 */;
03008                                         nextPC = 5 + MATCH_p; 
03009                                         
03010                                         #line 1043 "machine/pentium/disassembler.m"
03011                                         
03012 
03013                                                 sprintf (str,  "BSRod", DIS_REG32, DIS_EADDR32);
03014 
03015                                         
03016 
03017                                         
03018                                         
03019                                         
03020                                       } /*opt-block*//*opt-block+*/
03021                                       else 
03022                                         goto MATCH_label_a155;  /*opt-block+*/
03023                                       
03024                                       break;
03025                                     case 2: 
03026                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03027                                       if ((MATCH_w_8_16 & 0x7) 
03028                                               /* r_m at 16 */ == 4 && 
03029                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03030                                               /* index at 24 */ && 
03031                                         (MATCH_w_8_24 >> 3 & 0x7) 
03032                                               /* index at 24 */ < 8)) 
03033                                         goto MATCH_label_a156;  /*opt-block+*/
03034                                       else 
03035                                         goto MATCH_label_a157;  /*opt-block+*/
03036                                       
03037                                       break;
03038                                     case 3: 
03039                                       goto MATCH_label_a154; break;
03040                                     default: assert(0);
03041                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03042                                         -- mod at 16 --*/ 
03043                                 
03044                                 break;
03045                               case 6: 
03046                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03047                                 
03048                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03049                                         /* mod at 16 */) {
03050                                     case 0: 
03051                                       
03052                                         switch((MATCH_w_8_16 & 0x7) 
03053                                               /* r_m at 16 */) {
03054                                           case 0: case 1: case 2: case 3: 
03055                                           case 6: case 7: 
03056                                             goto MATCH_label_a158; break;
03057                                           case 4: 
03058                                             MATCH_w_8_24 = 
03059                                               getByte(3 + MATCH_p); 
03060                                             if ((MATCH_w_8_24 & 0x7) 
03061                                                     /* base at 24 */ == 5 && 
03062                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03063                                                     /* index at 24 */ && 
03064                                               (MATCH_w_8_24 >> 3 & 0x7) 
03065                                                     /* index at 24 */ < 8)) 
03066                                               goto MATCH_label_a160;  /*opt-block+*/
03067                                             else 
03068                                               goto MATCH_label_a159;  /*opt-block+*/
03069                                             
03070                                             break;
03071                                           case 5: 
03072                                             goto MATCH_label_a161; break;
03073                                           default: assert(0);
03074                                         } /* (MATCH_w_8_16 & 0x7) 
03075                                               -- r_m at 16 --*/ 
03076                                       break;
03077                                     case 1: 
03078                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03079                                       if ((MATCH_w_8_16 & 0x7) 
03080                                               /* r_m at 16 */ == 4 && 
03081                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03082                                               /* index at 24 */ && 
03083                                         (MATCH_w_8_24 >> 3 & 0x7) 
03084                                               /* index at 24 */ < 8)) { 
03085                                         unsigned Eaddr = 
03086                                           2 + addressToPC(MATCH_p);
03087                                         unsigned r32 = 
03088                                           (MATCH_w_8_16 >> 3 & 0x7) 
03089                                                 /* reg_opcode at 16 */;
03090                                         nextPC = 5 + MATCH_p; 
03091                                         
03092                                         #line 654 "machine/pentium/disassembler.m"
03093                                         
03094 
03095                                                 sprintf (str,  "MOVSX.Gv.Ebod", DIS_R32, DIS_EADDR8);
03096 
03097                                         
03098 
03099                                         
03100                                         
03101                                         
03102                                       } /*opt-block*//*opt-block+*/
03103                                       else 
03104                                         goto MATCH_label_a159;  /*opt-block+*/
03105                                       
03106                                       break;
03107                                     case 2: 
03108                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03109                                       if ((MATCH_w_8_16 & 0x7) 
03110                                               /* r_m at 16 */ == 4 && 
03111                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03112                                               /* index at 24 */ && 
03113                                         (MATCH_w_8_24 >> 3 & 0x7) 
03114                                               /* index at 24 */ < 8)) 
03115                                         goto MATCH_label_a160;  /*opt-block+*/
03116                                       else 
03117                                         goto MATCH_label_a161;  /*opt-block+*/
03118                                       
03119                                       break;
03120                                     case 3: 
03121                                       goto MATCH_label_a158; break;
03122                                     default: assert(0);
03123                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03124                                         -- mod at 16 --*/ 
03125                                 
03126                                 break;
03127                               case 7: 
03128                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03129                                 
03130                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03131                                         /* mod at 16 */) {
03132                                     case 0: 
03133                                       
03134                                         switch((MATCH_w_8_16 & 0x7) 
03135                                               /* r_m at 16 */) {
03136                                           case 0: case 1: case 2: case 3: 
03137                                           case 6: case 7: 
03138                                             goto MATCH_label_a162; break;
03139                                           case 4: 
03140                                             MATCH_w_8_24 = 
03141                                               getByte(3 + MATCH_p); 
03142                                             if ((MATCH_w_8_24 & 0x7) 
03143                                                     /* base at 24 */ == 5 && 
03144                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03145                                                     /* index at 24 */ && 
03146                                               (MATCH_w_8_24 >> 3 & 0x7) 
03147                                                     /* index at 24 */ < 8)) 
03148                                               goto MATCH_label_a164;  /*opt-block+*/
03149                                             else 
03150                                               goto MATCH_label_a163;  /*opt-block+*/
03151                                             
03152                                             break;
03153                                           case 5: 
03154                                             goto MATCH_label_a165; break;
03155                                           default: assert(0);
03156                                         } /* (MATCH_w_8_16 & 0x7) 
03157                                               -- r_m at 16 --*/ 
03158                                       break;
03159                                     case 1: 
03160                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03161                                       if ((MATCH_w_8_16 & 0x7) 
03162                                               /* r_m at 16 */ == 4 && 
03163                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03164                                               /* index at 24 */ && 
03165                                         (MATCH_w_8_24 >> 3 & 0x7) 
03166                                               /* index at 24 */ < 8)) { 
03167                                         unsigned Eaddr = 
03168                                           2 + addressToPC(MATCH_p);
03169                                         unsigned r32 = 
03170                                           (MATCH_w_8_16 >> 3 & 0x7) 
03171                                                 /* reg_opcode at 16 */;
03172                                         nextPC = 5 + MATCH_p; 
03173                                         
03174                                         #line 651 "machine/pentium/disassembler.m"
03175                                         
03176 
03177                                                 sprintf (str,  "MOVSX.Gv.Ew", DIS_R32, DIS_EADDR16);
03178 
03179                                         
03180 
03181                                         
03182                                         
03183                                         
03184                                       } /*opt-block*//*opt-block+*/
03185                                       else 
03186                                         goto MATCH_label_a163;  /*opt-block+*/
03187                                       
03188                                       break;
03189                                     case 2: 
03190                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03191                                       if ((MATCH_w_8_16 & 0x7) 
03192                                               /* r_m at 16 */ == 4 && 
03193                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03194                                               /* index at 24 */ && 
03195                                         (MATCH_w_8_24 >> 3 & 0x7) 
03196                                               /* index at 24 */ < 8)) 
03197                                         goto MATCH_label_a164;  /*opt-block+*/
03198                                       else 
03199                                         goto MATCH_label_a165;  /*opt-block+*/
03200                                       
03201                                       break;
03202                                     case 3: 
03203                                       goto MATCH_label_a162; break;
03204                                     default: assert(0);
03205                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03206                                         -- mod at 16 --*/ 
03207                                 
03208                                 break;
03209                               default: assert(0);
03210                             } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/  
03211                         else 
03212                           
03213                             switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
03214                               case 0: 
03215                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03216                                 
03217                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03218                                         /* mod at 16 */) {
03219                                     case 0: 
03220                                       
03221                                         switch((MATCH_w_8_16 & 0x7) 
03222                                               /* r_m at 16 */) {
03223                                           case 0: case 1: case 2: case 3: 
03224                                           case 6: case 7: 
03225                                             goto MATCH_label_a101; break;
03226                                           case 4: 
03227                                             MATCH_w_8_24 = 
03228                                               getByte(3 + MATCH_p); 
03229                                             if ((MATCH_w_8_24 & 0x7) 
03230                                                     /* base at 24 */ == 5 && 
03231                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03232                                                     /* index at 24 */ && 
03233                                               (MATCH_w_8_24 >> 3 & 0x7) 
03234                                                     /* index at 24 */ < 8)) 
03235                                               goto MATCH_label_a103;  /*opt-block+*/
03236                                             else 
03237                                               goto MATCH_label_a102;  /*opt-block+*/
03238                                             
03239                                             break;
03240                                           case 5: 
03241                                             goto MATCH_label_a104; break;
03242                                           default: assert(0);
03243                                         } /* (MATCH_w_8_16 & 0x7) 
03244                                               -- r_m at 16 --*/ 
03245                                       break;
03246                                     case 1: 
03247                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03248                                       if ((MATCH_w_8_16 & 0x7) 
03249                                               /* r_m at 16 */ == 4 && 
03250                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03251                                               /* index at 24 */ && 
03252                                         (MATCH_w_8_24 >> 3 & 0x7) 
03253                                               /* index at 24 */ < 8)) { 
03254                                         unsigned Eaddr = 
03255                                           2 + addressToPC(MATCH_p);
03256                                         unsigned reg = 
03257                                           (MATCH_w_8_16 >> 3 & 0x7) 
03258                                                 /* reg_opcode at 16 */;
03259                                         nextPC = 5 + MATCH_p; 
03260                                         
03261                                         #line 947 "machine/pentium/disassembler.m"
03262                                         
03263 
03264                                                 sprintf (str,  "CMPXCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
03265 
03266                                         
03267 
03268                                         
03269                                         
03270                                         
03271                                       } /*opt-block*//*opt-block+*/
03272                                       else 
03273                                         goto MATCH_label_a102;  /*opt-block+*/
03274                                       
03275                                       break;
03276                                     case 2: 
03277                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03278                                       if ((MATCH_w_8_16 & 0x7) 
03279                                               /* r_m at 16 */ == 4 && 
03280                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03281                                               /* index at 24 */ && 
03282                                         (MATCH_w_8_24 >> 3 & 0x7) 
03283                                               /* index at 24 */ < 8)) 
03284                                         goto MATCH_label_a103;  /*opt-block+*/
03285                                       else 
03286                                         goto MATCH_label_a104;  /*opt-block+*/
03287                                       
03288                                       break;
03289                                     case 3: 
03290                                       goto MATCH_label_a101; break;
03291                                     default: assert(0);
03292                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03293                                         -- mod at 16 --*/ 
03294                                 
03295                                 break;
03296                               case 1: 
03297                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03298                                 
03299                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03300                                         /* mod at 16 */) {
03301                                     case 0: 
03302                                       
03303                                         switch((MATCH_w_8_16 & 0x7) 
03304                                               /* r_m at 16 */) {
03305                                           case 0: case 1: case 2: case 3: 
03306                                           case 6: case 7: 
03307                                             goto MATCH_label_a105; break;
03308                                           case 4: 
03309                                             MATCH_w_8_24 = 
03310                                               getByte(3 + MATCH_p); 
03311                                             if ((MATCH_w_8_24 & 0x7) 
03312                                                     /* base at 24 */ == 5 && 
03313                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03314                                                     /* index at 24 */ && 
03315                                               (MATCH_w_8_24 >> 3 & 0x7) 
03316                                                     /* index at 24 */ < 8)) 
03317                                               goto MATCH_label_a107;  /*opt-block+*/
03318                                             else 
03319                                               goto MATCH_label_a106;  /*opt-block+*/
03320                                             
03321                                             break;
03322                                           case 5: 
03323                                             goto MATCH_label_a108; break;
03324                                           default: assert(0);
03325                                         } /* (MATCH_w_8_16 & 0x7) 
03326                                               -- r_m at 16 --*/ 
03327                                       break;
03328                                     case 1: 
03329                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03330                                       if ((MATCH_w_8_16 & 0x7) 
03331                                               /* r_m at 16 */ == 4 && 
03332                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03333                                               /* index at 24 */ && 
03334                                         (MATCH_w_8_24 >> 3 & 0x7) 
03335                                               /* index at 24 */ < 8)) { 
03336                                         unsigned Eaddr = 
03337                                           2 + addressToPC(MATCH_p);
03338                                         unsigned reg = 
03339                                           (MATCH_w_8_16 >> 3 & 0x7) 
03340                                                 /* reg_opcode at 16 */;
03341                                         nextPC = 5 + MATCH_p; 
03342                                         
03343                                         #line 941 "machine/pentium/disassembler.m"
03344                                         
03345 
03346                                                 sprintf (str,  "CMPXCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
03347 
03348                                         
03349 
03350                                         
03351                                         
03352                                         
03353                                       } /*opt-block*//*opt-block+*/
03354                                       else 
03355                                         goto MATCH_label_a106;  /*opt-block+*/
03356                                       
03357                                       break;
03358                                     case 2: 
03359                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03360                                       if ((MATCH_w_8_16 & 0x7) 
03361                                               /* r_m at 16 */ == 4 && 
03362                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03363                                               /* index at 24 */ && 
03364                                         (MATCH_w_8_24 >> 3 & 0x7) 
03365                                               /* index at 24 */ < 8)) 
03366                                         goto MATCH_label_a107;  /*opt-block+*/
03367                                       else 
03368                                         goto MATCH_label_a108;  /*opt-block+*/
03369                                       
03370                                       break;
03371                                     case 3: 
03372                                       goto MATCH_label_a105; break;
03373                                     default: assert(0);
03374                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03375                                         -- mod at 16 --*/ 
03376                                 
03377                                 break;
03378                               case 2: 
03379                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03380                                 
03381                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03382                                         /* mod at 16 */) {
03383                                     case 0: 
03384                                       
03385                                         switch((MATCH_w_8_16 & 0x7) 
03386                                               /* r_m at 16 */) {
03387                                           case 0: case 1: case 2: case 3: 
03388                                           case 6: case 7: 
03389                                             { 
03390                                               unsigned Mem = 
03391                                                 2 + addressToPC(MATCH_p);
03392                                               unsigned reg = 
03393                                                 (MATCH_w_8_16 >> 3 & 0x7) 
03394                                                       /* reg_opcode at 16 */;
03395                                               nextPC = 3 + MATCH_p; 
03396                                               
03397                                               #line 748 "machine/pentium/disassembler.m"
03398                                               
03399 
03400                                                       sprintf (str,  "LSS", DIS_REG32, DIS_MEM);
03401 
03402                                               
03403 
03404                                               
03405                                               
03406                                               
03407                                             }
03408                                             
03409                                             break;
03410                                           case 4: 
03411                                             MATCH_w_8_24 = 
03412                                               getByte(3 + MATCH_p); 
03413                                             if ((MATCH_w_8_24 & 0x7) 
03414                                                     /* base at 24 */ == 5 && 
03415                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03416                                                     /* index at 24 */ && 
03417                                               (MATCH_w_8_24 >> 3 & 0x7) 
03418                                                     /* index at 24 */ < 8)) 
03419                                               goto MATCH_label_a110;  /*opt-block+*/
03420                                             else 
03421                                               goto MATCH_label_a109;  /*opt-block+*/
03422                                             
03423                                             break;
03424                                           case 5: 
03425                                             goto MATCH_label_a111; break;
03426                                           default: assert(0);
03427                                         } /* (MATCH_w_8_16 & 0x7) 
03428                                               -- r_m at 16 --*/ 
03429                                       break;
03430                                     case 1: 
03431                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03432                                       if ((MATCH_w_8_16 & 0x7) 
03433                                               /* r_m at 16 */ == 4 && 
03434                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03435                                               /* index at 24 */ && 
03436                                         (MATCH_w_8_24 >> 3 & 0x7) 
03437                                               /* index at 24 */ < 8)) { 
03438                                         unsigned Mem = 
03439                                           2 + addressToPC(MATCH_p);
03440                                         unsigned reg = 
03441                                           (MATCH_w_8_16 >> 3 & 0x7) 
03442                                                 /* reg_opcode at 16 */;
03443                                         nextPC = 5 + MATCH_p; 
03444                                         
03445                                         #line 748 "machine/pentium/disassembler.m"
03446                                         
03447 
03448                                                 sprintf (str,  "LSS", DIS_REG32, DIS_MEM);
03449 
03450                                         
03451 
03452                                         
03453                                         
03454                                         
03455                                       } /*opt-block*//*opt-block+*/
03456                                       else 
03457                                         goto MATCH_label_a109;  /*opt-block+*/
03458                                       
03459                                       break;
03460                                     case 2: 
03461                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03462                                       if ((MATCH_w_8_16 & 0x7) 
03463                                               /* r_m at 16 */ == 4 && 
03464                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03465                                               /* index at 24 */ && 
03466                                         (MATCH_w_8_24 >> 3 & 0x7) 
03467                                               /* index at 24 */ < 8)) 
03468                                         goto MATCH_label_a110;  /*opt-block+*/
03469                                       else 
03470                                         goto MATCH_label_a111;  /*opt-block+*/
03471                                       
03472                                       break;
03473                                     case 3: 
03474                                       goto MATCH_label_a39; break;
03475                                     default: assert(0);
03476                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03477                                         -- mod at 16 --*/ 
03478                                 
03479                                 break;
03480                               case 3: 
03481                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03482                                 
03483                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03484                                         /* mod at 16 */) {
03485                                     case 0: 
03486                                       
03487                                         switch((MATCH_w_8_16 & 0x7) 
03488                                               /* r_m at 16 */) {
03489                                           case 0: case 1: case 2: case 3: 
03490                                           case 6: case 7: 
03491                                             goto MATCH_label_a112; break;
03492                                           case 4: 
03493                                             MATCH_w_8_24 = 
03494                                               getByte(3 + MATCH_p); 
03495                                             if ((MATCH_w_8_24 & 0x7) 
03496                                                     /* base at 24 */ == 5 && 
03497                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03498                                                     /* index at 24 */ && 
03499                                               (MATCH_w_8_24 >> 3 & 0x7) 
03500                                                     /* index at 24 */ < 8)) 
03501                                               goto MATCH_label_a114;  /*opt-block+*/
03502                                             else 
03503                                               goto MATCH_label_a113;  /*opt-block+*/
03504                                             
03505                                             break;
03506                                           case 5: 
03507                                             goto MATCH_label_a115; break;
03508                                           default: assert(0);
03509                                         } /* (MATCH_w_8_16 & 0x7) 
03510                                               -- r_m at 16 --*/ 
03511                                       break;
03512                                     case 1: 
03513                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03514                                       if ((MATCH_w_8_16 & 0x7) 
03515                                               /* r_m at 16 */ == 4 && 
03516                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03517                                               /* index at 24 */ && 
03518                                         (MATCH_w_8_24 >> 3 & 0x7) 
03519                                               /* index at 24 */ < 8)) { 
03520                                         unsigned Eaddr = 
03521                                           2 + addressToPC(MATCH_p);
03522                                         unsigned reg = 
03523                                           (MATCH_w_8_16 >> 3 & 0x7) 
03524                                                 /* reg_opcode at 16 */;
03525                                         nextPC = 5 + MATCH_p; 
03526                                         
03527                                         #line 1010 "machine/pentium/disassembler.m"
03528                                         
03529 
03530                                                 sprintf (str,  "BTRod", DIS_EADDR32, DIS_REG32);
03531 
03532                                         
03533 
03534                                         
03535                                         
03536                                         
03537                                       } /*opt-block*//*opt-block+*/
03538                                       else 
03539                                         goto MATCH_label_a113;  /*opt-block+*/
03540                                       
03541                                       break;
03542                                     case 2: 
03543                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03544                                       if ((MATCH_w_8_16 & 0x7) 
03545                                               /* r_m at 16 */ == 4 && 
03546                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03547                                               /* index at 24 */ && 
03548                                         (MATCH_w_8_24 >> 3 & 0x7) 
03549                                               /* index at 24 */ < 8)) 
03550                                         goto MATCH_label_a114;  /*opt-block+*/
03551                                       else 
03552                                         goto MATCH_label_a115;  /*opt-block+*/
03553                                       
03554                                       break;
03555                                     case 3: 
03556                                       goto MATCH_label_a112; break;
03557                                     default: assert(0);
03558                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03559                                         -- mod at 16 --*/ 
03560                                 
03561                                 break;
03562                               case 4: 
03563                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03564                                 
03565                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03566                                         /* mod at 16 */) {
03567                                     case 0: 
03568                                       
03569                                         switch((MATCH_w_8_16 & 0x7) 
03570                                               /* r_m at 16 */) {
03571                                           case 0: case 1: case 2: case 3: 
03572                                           case 6: case 7: 
03573                                             { 
03574                                               unsigned Mem = 
03575                                                 2 + addressToPC(MATCH_p);
03576                                               unsigned reg = 
03577                                                 (MATCH_w_8_16 >> 3 & 0x7) 
03578                                                       /* reg_opcode at 16 */;
03579                                               nextPC = 3 + MATCH_p; 
03580                                               
03581                                               #line 769 "machine/pentium/disassembler.m"
03582                                               
03583 
03584                                                       sprintf (str,  "LFS", DIS_REG32, DIS_MEM);
03585 
03586                                               
03587 
03588                                               
03589                                               
03590                                               
03591                                             }
03592                                             
03593                                             break;
03594                                           case 4: 
03595                                             MATCH_w_8_24 = 
03596                                               getByte(3 + MATCH_p); 
03597                                             if ((MATCH_w_8_24 & 0x7) 
03598                                                     /* base at 24 */ == 5 && 
03599                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03600                                                     /* index at 24 */ && 
03601                                               (MATCH_w_8_24 >> 3 & 0x7) 
03602                                                     /* index at 24 */ < 8)) 
03603                                               goto MATCH_label_a117;  /*opt-block+*/
03604                                             else 
03605                                               goto MATCH_label_a116;  /*opt-block+*/
03606                                             
03607                                             break;
03608                                           case 5: 
03609                                             goto MATCH_label_a118; break;
03610                                           default: assert(0);
03611                                         } /* (MATCH_w_8_16 & 0x7) 
03612                                               -- r_m at 16 --*/ 
03613                                       break;
03614                                     case 1: 
03615                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03616                                       if ((MATCH_w_8_16 & 0x7) 
03617                                               /* r_m at 16 */ == 4 && 
03618                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03619                                               /* index at 24 */ && 
03620                                         (MATCH_w_8_24 >> 3 & 0x7) 
03621                                               /* index at 24 */ < 8)) { 
03622                                         unsigned Mem = 
03623                                           2 + addressToPC(MATCH_p);
03624                                         unsigned reg = 
03625                                           (MATCH_w_8_16 >> 3 & 0x7) 
03626                                                 /* reg_opcode at 16 */;
03627                                         nextPC = 5 + MATCH_p; 
03628                                         
03629                                         #line 769 "machine/pentium/disassembler.m"
03630                                         
03631 
03632                                                 sprintf (str,  "LFS", DIS_REG32, DIS_MEM);
03633 
03634                                         
03635 
03636                                         
03637                                         
03638                                         
03639                                       } /*opt-block*//*opt-block+*/
03640                                       else 
03641                                         goto MATCH_label_a116;  /*opt-block+*/
03642                                       
03643                                       break;
03644                                     case 2: 
03645                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03646                                       if ((MATCH_w_8_16 & 0x7) 
03647                                               /* r_m at 16 */ == 4 && 
03648                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03649                                               /* index at 24 */ && 
03650                                         (MATCH_w_8_24 >> 3 & 0x7) 
03651                                               /* index at 24 */ < 8)) 
03652                                         goto MATCH_label_a117;  /*opt-block+*/
03653                                       else 
03654                                         goto MATCH_label_a118;  /*opt-block+*/
03655                                       
03656                                       break;
03657                                     case 3: 
03658                                       goto MATCH_label_a39; break;
03659                                     default: assert(0);
03660                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03661                                         -- mod at 16 --*/ 
03662                                 
03663                                 break;
03664                               case 5: 
03665                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03666                                 
03667                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03668                                         /* mod at 16 */) {
03669                                     case 0: 
03670                                       
03671                                         switch((MATCH_w_8_16 & 0x7) 
03672                                               /* r_m at 16 */) {
03673                                           case 0: case 1: case 2: case 3: 
03674                                           case 6: case 7: 
03675                                             { 
03676                                               unsigned Mem = 
03677                                                 2 + addressToPC(MATCH_p);
03678                                               unsigned reg = 
03679                                                 (MATCH_w_8_16 >> 3 & 0x7) 
03680                                                       /* reg_opcode at 16 */;
03681                                               nextPC = 3 + MATCH_p; 
03682                                               
03683                                               #line 766 "machine/pentium/disassembler.m"
03684                                               
03685 
03686                                                       sprintf (str,  "LGS", DIS_REG32, DIS_MEM);
03687 
03688                                               
03689 
03690                                               
03691                                               
03692                                               
03693                                             }
03694                                             
03695                                             break;
03696                                           case 4: 
03697                                             MATCH_w_8_24 = 
03698                                               getByte(3 + MATCH_p); 
03699                                             if ((MATCH_w_8_24 & 0x7) 
03700                                                     /* base at 24 */ == 5 && 
03701                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03702                                                     /* index at 24 */ && 
03703                                               (MATCH_w_8_24 >> 3 & 0x7) 
03704                                                     /* index at 24 */ < 8)) 
03705                                               goto MATCH_label_a120;  /*opt-block+*/
03706                                             else 
03707                                               goto MATCH_label_a119;  /*opt-block+*/
03708                                             
03709                                             break;
03710                                           case 5: 
03711                                             goto MATCH_label_a121; break;
03712                                           default: assert(0);
03713                                         } /* (MATCH_w_8_16 & 0x7) 
03714                                               -- r_m at 16 --*/ 
03715                                       break;
03716                                     case 1: 
03717                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03718                                       if ((MATCH_w_8_16 & 0x7) 
03719                                               /* r_m at 16 */ == 4 && 
03720                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03721                                               /* index at 24 */ && 
03722                                         (MATCH_w_8_24 >> 3 & 0x7) 
03723                                               /* index at 24 */ < 8)) { 
03724                                         unsigned Mem = 
03725                                           2 + addressToPC(MATCH_p);
03726                                         unsigned reg = 
03727                                           (MATCH_w_8_16 >> 3 & 0x7) 
03728                                                 /* reg_opcode at 16 */;
03729                                         nextPC = 5 + MATCH_p; 
03730                                         
03731                                         #line 766 "machine/pentium/disassembler.m"
03732                                         
03733 
03734                                                 sprintf (str,  "LGS", DIS_REG32, DIS_MEM);
03735 
03736                                         
03737 
03738                                         
03739                                         
03740                                         
03741                                       } /*opt-block*//*opt-block+*/
03742                                       else 
03743                                         goto MATCH_label_a119;  /*opt-block+*/
03744                                       
03745                                       break;
03746                                     case 2: 
03747                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03748                                       if ((MATCH_w_8_16 & 0x7) 
03749                                               /* r_m at 16 */ == 4 && 
03750                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03751                                               /* index at 24 */ && 
03752                                         (MATCH_w_8_24 >> 3 & 0x7) 
03753                                               /* index at 24 */ < 8)) 
03754                                         goto MATCH_label_a120;  /*opt-block+*/
03755                                       else 
03756                                         goto MATCH_label_a121;  /*opt-block+*/
03757                                       
03758                                       break;
03759                                     case 3: 
03760                                       goto MATCH_label_a39; break;
03761                                     default: assert(0);
03762                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03763                                         -- mod at 16 --*/ 
03764                                 
03765                                 break;
03766                               case 6: 
03767                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03768                                 
03769                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03770                                         /* mod at 16 */) {
03771                                     case 0: 
03772                                       
03773                                         switch((MATCH_w_8_16 & 0x7) 
03774                                               /* r_m at 16 */) {
03775                                           case 0: case 1: case 2: case 3: 
03776                                           case 6: case 7: 
03777                                             goto MATCH_label_a122; break;
03778                                           case 4: 
03779                                             MATCH_w_8_24 = 
03780                                               getByte(3 + MATCH_p); 
03781                                             if ((MATCH_w_8_24 & 0x7) 
03782                                                     /* base at 24 */ == 5 && 
03783                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03784                                                     /* index at 24 */ && 
03785                                               (MATCH_w_8_24 >> 3 & 0x7) 
03786                                                     /* index at 24 */ < 8)) 
03787                                               goto MATCH_label_a124;  /*opt-block+*/
03788                                             else 
03789                                               goto MATCH_label_a123;  /*opt-block+*/
03790                                             
03791                                             break;
03792                                           case 5: 
03793                                             goto MATCH_label_a125; break;
03794                                           default: assert(0);
03795                                         } /* (MATCH_w_8_16 & 0x7) 
03796                                               -- r_m at 16 --*/ 
03797                                       break;
03798                                     case 1: 
03799                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03800                                       if ((MATCH_w_8_16 & 0x7) 
03801                                               /* r_m at 16 */ == 4 && 
03802                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03803                                               /* index at 24 */ && 
03804                                         (MATCH_w_8_24 >> 3 & 0x7) 
03805                                               /* index at 24 */ < 8)) { 
03806                                         unsigned Eaddr = 
03807                                           2 + addressToPC(MATCH_p);
03808                                         unsigned r32 = 
03809                                           (MATCH_w_8_16 >> 3 & 0x7) 
03810                                                 /* reg_opcode at 16 */;
03811                                         nextPC = 5 + MATCH_p; 
03812                                         
03813                                         #line 645 "machine/pentium/disassembler.m"
03814                                         
03815 
03816                                                 sprintf (str,  "MOVZX.Gv.Ebod", DIS_R32, DIS_EADDR8);
03817 
03818                                         
03819 
03820                                         
03821                                         
03822                                         
03823                                       } /*opt-block*//*opt-block+*/
03824                                       else 
03825                                         goto MATCH_label_a123;  /*opt-block+*/
03826                                       
03827                                       break;
03828                                     case 2: 
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                                         goto MATCH_label_a124;  /*opt-block+*/
03837                                       else 
03838                                         goto MATCH_label_a125;  /*opt-block+*/
03839                                       
03840                                       break;
03841                                     case 3: 
03842                                       goto MATCH_label_a122; break;
03843                                     default: assert(0);
03844                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03845                                         -- mod at 16 --*/ 
03846                                 
03847                                 break;
03848                               case 7: 
03849                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03850                                 
03851                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03852                                         /* mod at 16 */) {
03853                                     case 0: 
03854                                       
03855                                         switch((MATCH_w_8_16 & 0x7) 
03856                                               /* r_m at 16 */) {
03857                                           case 0: case 1: case 2: case 3: 
03858                                           case 6: case 7: 
03859                                             goto MATCH_label_a126; break;
03860                                           case 4: 
03861                                             MATCH_w_8_24 = 
03862                                               getByte(3 + MATCH_p); 
03863                                             if ((MATCH_w_8_24 & 0x7) 
03864                                                     /* base at 24 */ == 5 && 
03865                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03866                                                     /* index at 24 */ && 
03867                                               (MATCH_w_8_24 >> 3 & 0x7) 
03868                                                     /* index at 24 */ < 8)) 
03869                                               goto MATCH_label_a128;  /*opt-block+*/
03870                                             else 
03871                                               goto MATCH_label_a127;  /*opt-block+*/
03872                                             
03873                                             break;
03874                                           case 5: 
03875                                             goto MATCH_label_a129; break;
03876                                           default: assert(0);
03877                                         } /* (MATCH_w_8_16 & 0x7) 
03878                                               -- r_m at 16 --*/ 
03879                                       break;
03880                                     case 1: 
03881                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03882                                       if ((MATCH_w_8_16 & 0x7) 
03883                                               /* r_m at 16 */ == 4 && 
03884                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03885                                               /* index at 24 */ && 
03886                                         (MATCH_w_8_24 >> 3 & 0x7) 
03887                                               /* index at 24 */ < 8)) { 
03888                                         unsigned Eaddr = 
03889                                           2 + addressToPC(MATCH_p);
03890                                         unsigned r32 = 
03891                                           (MATCH_w_8_16 >> 3 & 0x7) 
03892                                                 /* reg_opcode at 16 */;
03893                                         nextPC = 5 + MATCH_p; 
03894                                         
03895                                         #line 642 "machine/pentium/disassembler.m"
03896                                         
03897 
03898                                                 sprintf (str,  "MOVZX.Gv.Ew", DIS_R32, DIS_EADDR16);
03899 
03900                                         
03901 
03902                                         
03903                                         
03904                                         
03905                                       } /*opt-block*//*opt-block+*/
03906                                       else 
03907                                         goto MATCH_label_a127;  /*opt-block+*/
03908                                       
03909                                       break;
03910                                     case 2: 
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                                         goto MATCH_label_a128;  /*opt-block+*/
03919                                       else 
03920                                         goto MATCH_label_a129;  /*opt-block+*/
03921                                       
03922                                       break;
03923                                     case 3: 
03924                                       goto MATCH_label_a126; break;
03925                                     default: assert(0);
03926                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
03927                                         -- mod at 16 --*/ 
03928                                 
03929                                 break;
03930                               default: assert(0);
03931                             } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/  
03932                         break;
03933                       case 12: 
03934                         if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) { 
03935                           unsigned r32 = (MATCH_w_8_8 & 0x7) /* r32 at 8 */;
03936                           nextPC = 2 + MATCH_p; 
03937                           
03938                           #line 1040 "machine/pentium/disassembler.m"
03939                           
03940 
03941                                   sprintf (str,  "BSWAP", DIS_R32);
03942 
03943                           
03944 
03945                           
03946                           
03947                           
03948                         } /*opt-block*//*opt-block+*/
03949                         else 
03950                           
03951                             switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
03952                               case 0: 
03953                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
03954                                 
03955                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
03956                                         /* mod at 16 */) {
03957                                     case 0: 
03958                                       
03959                                         switch((MATCH_w_8_16 & 0x7) 
03960                                               /* r_m at 16 */) {
03961                                           case 0: case 1: case 2: case 3: 
03962                                           case 6: case 7: 
03963                                             goto MATCH_label_a166; break;
03964                                           case 4: 
03965                                             MATCH_w_8_24 = 
03966                                               getByte(3 + MATCH_p); 
03967                                             if ((MATCH_w_8_24 & 0x7) 
03968                                                     /* base at 24 */ == 5 && 
03969                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03970                                                     /* index at 24 */ && 
03971                                               (MATCH_w_8_24 >> 3 & 0x7) 
03972                                                     /* index at 24 */ < 8)) 
03973                                               goto MATCH_label_a168;  /*opt-block+*/
03974                                             else 
03975                                               goto MATCH_label_a167;  /*opt-block+*/
03976                                             
03977                                             break;
03978                                           case 5: 
03979                                             goto MATCH_label_a169; break;
03980                                           default: assert(0);
03981                                         } /* (MATCH_w_8_16 & 0x7) 
03982                                               -- r_m at 16 --*/ 
03983                                       break;
03984                                     case 1: 
03985                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
03986                                       if ((MATCH_w_8_16 & 0x7) 
03987                                               /* r_m at 16 */ == 4 && 
03988                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
03989                                               /* index at 24 */ && 
03990                                         (MATCH_w_8_24 >> 3 & 0x7) 
03991                                               /* index at 24 */ < 8)) { 
03992                                         unsigned Eaddr = 
03993                                           2 + addressToPC(MATCH_p);
03994                                         unsigned reg = 
03995                                           (MATCH_w_8_16 >> 3 & 0x7) 
03996                                                 /* reg_opcode at 16 */;
03997                                         nextPC = 5 + MATCH_p; 
03998                                         
03999                                         #line 77 "machine/pentium/disassembler.m"
04000                                         
04001 
04002                                                 sprintf (str,  "XADD.Eb.Gb", DIS_EADDR8, DIS_REG8);
04003 
04004                                         
04005 
04006                                         
04007                                         
04008                                         
04009                                       } /*opt-block*//*opt-block+*/
04010                                       else 
04011                                         goto MATCH_label_a167;  /*opt-block+*/
04012                                       
04013                                       break;
04014                                     case 2: 
04015                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
04016                                       if ((MATCH_w_8_16 & 0x7) 
04017                                               /* r_m at 16 */ == 4 && 
04018                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04019                                               /* index at 24 */ && 
04020                                         (MATCH_w_8_24 >> 3 & 0x7) 
04021                                               /* index at 24 */ < 8)) 
04022                                         goto MATCH_label_a168;  /*opt-block+*/
04023                                       else 
04024                                         goto MATCH_label_a169;  /*opt-block+*/
04025                                       
04026                                       break;
04027                                     case 3: 
04028                                       goto MATCH_label_a166; break;
04029                                     default: assert(0);
04030                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
04031                                         -- mod at 16 --*/ 
04032                                 
04033                                 break;
04034                               case 1: 
04035                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
04036                                 
04037                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
04038                                         /* mod at 16 */) {
04039                                     case 0: 
04040                                       
04041                                         switch((MATCH_w_8_16 & 0x7) 
04042                                               /* r_m at 16 */) {
04043                                           case 0: case 1: case 2: case 3: 
04044                                           case 6: case 7: 
04045                                             goto MATCH_label_a170; break;
04046                                           case 4: 
04047                                             MATCH_w_8_24 = 
04048                                               getByte(3 + MATCH_p); 
04049                                             if ((MATCH_w_8_24 & 0x7) 
04050                                                     /* base at 24 */ == 5 && 
04051                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04052                                                     /* index at 24 */ && 
04053                                               (MATCH_w_8_24 >> 3 & 0x7) 
04054                                                     /* index at 24 */ < 8)) 
04055                                               goto MATCH_label_a172;  /*opt-block+*/
04056                                             else 
04057                                               goto MATCH_label_a171;  /*opt-block+*/
04058                                             
04059                                             break;
04060                                           case 5: 
04061                                             goto MATCH_label_a173; break;
04062                                           default: assert(0);
04063                                         } /* (MATCH_w_8_16 & 0x7) 
04064                                               -- r_m at 16 --*/ 
04065                                       break;
04066                                     case 1: 
04067                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
04068                                       if ((MATCH_w_8_16 & 0x7) 
04069                                               /* r_m at 16 */ == 4 && 
04070                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04071                                               /* index at 24 */ && 
04072                                         (MATCH_w_8_24 >> 3 & 0x7) 
04073                                               /* index at 24 */ < 8)) { 
04074                                         unsigned Eaddr = 
04075                                           2 + addressToPC(MATCH_p);
04076                                         unsigned reg = 
04077                                           (MATCH_w_8_16 >> 3 & 0x7) 
04078                                                 /* reg_opcode at 16 */;
04079                                         nextPC = 5 + MATCH_p; 
04080                                         
04081                                         #line 71 "machine/pentium/disassembler.m"
04082                                         
04083 
04084                                                 sprintf (str,  "XADD.Ev.Gvod", DIS_EADDR32, DIS_REG32);
04085 
04086                                         
04087 
04088                                         
04089                                         
04090                                         
04091                                       } /*opt-block*//*opt-block+*/
04092                                       else 
04093                                         goto MATCH_label_a171;  /*opt-block+*/
04094                                       
04095                                       break;
04096                                     case 2: 
04097                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
04098                                       if ((MATCH_w_8_16 & 0x7) 
04099                                               /* r_m at 16 */ == 4 && 
04100                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04101                                               /* index at 24 */ && 
04102                                         (MATCH_w_8_24 >> 3 & 0x7) 
04103                                               /* index at 24 */ < 8)) 
04104                                         goto MATCH_label_a172;  /*opt-block+*/
04105                                       else 
04106                                         goto MATCH_label_a173;  /*opt-block+*/
04107                                       
04108                                       break;
04109                                     case 3: 
04110                                       goto MATCH_label_a170; break;
04111                                     default: assert(0);
04112                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
04113                                         -- mod at 16 --*/ 
04114                                 
04115                                 break;
04116                               case 2: case 3: case 4: case 5: case 6: 
04117                                 goto MATCH_label_a39; break;
04118                               case 7: 
04119                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
04120                                 if ((MATCH_w_8_16 >> 3 & 0x7) 
04121                                         /* reg_opcode at 16 */ == 1) 
04122                                   
04123                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
04124                                           /* mod at 16 */) {
04125                                       case 0: 
04126                                         
04127                                           switch((MATCH_w_8_16 & 0x7) 
04128                                                 /* r_m at 16 */) {
04129                                             case 0: case 1: case 2: case 3: 
04130                                             case 6: case 7: 
04131                                               { 
04132                                                 unsigned Mem = 
04133                                                   2 + addressToPC(MATCH_p);
04134                                                 nextPC = 3 + MATCH_p; 
04135                                                 
04136                                                 #line 938 "machine/pentium/disassembler.m"
04137                                                 
04138 
04139                                                         sprintf (str,  "CMPXCHG8B", DIS_MEM);
04140 
04141                                                 
04142 
04143                                                 
04144                                                 
04145                                                 
04146                                               }
04147                                               
04148                                               break;
04149                                             case 4: 
04150                                               MATCH_w_8_24 = 
04151                                                 getByte(3 + MATCH_p); 
04152                                               if ((MATCH_w_8_24 & 0x7) 
04153                                                       /* base at 24 */ == 5 && 
04154                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04155                                                       /* index at 24 */ && 
04156                                                 (MATCH_w_8_24 >> 3 & 0x7) 
04157                                                       /* index at 24 */ < 8)) 
04158                                                 goto MATCH_label_a175;  /*opt-block+*/
04159                                               else 
04160                                                 goto MATCH_label_a174;  /*opt-block+*/
04161                                               
04162                                               break;
04163                                             case 5: 
04164                                               goto MATCH_label_a176; break;
04165                                             default: assert(0);
04166                                           } /* (MATCH_w_8_16 & 0x7) 
04167                                                 -- r_m at 16 --*/ 
04168                                         break;
04169                                       case 1: 
04170                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
04171                                         if ((MATCH_w_8_16 & 0x7) 
04172                                                 /* r_m at 16 */ == 4 && 
04173                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04174                                                 /* index at 24 */ && 
04175                                           (MATCH_w_8_24 >> 3 & 0x7) 
04176                                                 /* index at 24 */ < 8)) { 
04177                                           unsigned Mem = 
04178                                             2 + addressToPC(MATCH_p);
04179                                           nextPC = 5 + MATCH_p; 
04180                                           
04181                                           #line 938 "machine/pentium/disassembler.m"
04182                                           
04183 
04184                                                   sprintf (str,  "CMPXCHG8B", DIS_MEM);
04185 
04186                                           
04187 
04188                                           
04189                                           
04190                                           
04191                                         } /*opt-block*//*opt-block+*/
04192                                         else 
04193                                           goto MATCH_label_a174;  /*opt-block+*/
04194                                         
04195                                         break;
04196                                       case 2: 
04197                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
04198                                         if ((MATCH_w_8_16 & 0x7) 
04199                                                 /* r_m at 16 */ == 4 && 
04200                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
04201                                                 /* index at 24 */ && 
04202                                           (MATCH_w_8_24 >> 3 & 0x7) 
04203                                                 /* index at 24 */ < 8)) 
04204                                           goto MATCH_label_a175;  /*opt-block+*/
04205                                         else 
04206                                           goto MATCH_label_a176;  /*opt-block+*/
04207                                         
04208                                         break;
04209                                       case 3: 
04210                                         goto MATCH_label_a39; break;
04211                                       default: assert(0);
04212                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
04213                                           -- mod at 16 --*/  
04214                                 else 
04215                                   goto MATCH_label_a39;  /*opt-block+*/
04216                                 
04217                                 break;
04218                               default: assert(0);
04219                             } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/  
04220                         break;
04221                       default: assert(0);
04222                     } /* (MATCH_w_8_8 >> 4 & 0xf) -- row at 8 --*/ 
04223                   
04224                   break;
04225                 default: assert(0);
04226               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/  
04227           else 
04228             
04229               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
04230                 case 0: 
04231                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
04232                   
04233                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
04234                       case 0: 
04235                         
04236                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
04237                             case 0: case 1: case 2: case 3: case 6: case 7: 
04238                               goto MATCH_label_a0; break;
04239                             case 4: 
04240                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
04241                               if ((MATCH_w_8_16 & 0x7) 
04242                                       /* base at 16 */ == 5 && 
04243                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04244                                       /* index at 16 */ && 
04245                                 (MATCH_w_8_16 >> 3 & 0x7) 
04246                                       /* index at 16 */ < 8)) 
04247                                 goto MATCH_label_a2;  /*opt-block+*/
04248                               else 
04249                                 goto MATCH_label_a1;  /*opt-block+*/
04250                               
04251                               break;
04252                             case 5: 
04253                               goto MATCH_label_a3; break;
04254                             default: assert(0);
04255                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
04256                         break;
04257                       case 1: 
04258                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
04259                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
04260                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04261                                 /* index at 16 */ && 
04262                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
04263                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
04264                           unsigned r8 = 
04265                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
04266                           nextPC = 4 + MATCH_p; 
04267                           
04268                           #line 1219 "machine/pentium/disassembler.m"
04269                           
04270 
04271                                   sprintf (str,  "ADDmrb", DIS_EADDR8, DIS_R8);
04272 
04273                           
04274 
04275                           
04276                           
04277                           
04278                         } /*opt-block*//*opt-block+*/
04279                         else 
04280                           goto MATCH_label_a1;  /*opt-block+*/
04281                         
04282                         break;
04283                       case 2: 
04284                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
04285                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
04286                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04287                                 /* index at 16 */ && 
04288                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
04289                           goto MATCH_label_a2;  /*opt-block+*/
04290                         else 
04291                           goto MATCH_label_a3;  /*opt-block+*/
04292                         
04293                         break;
04294                       case 3: 
04295                         goto MATCH_label_a0; break;
04296                       default: assert(0);
04297                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
04298                   
04299                   break;
04300                 case 1: 
04301                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
04302                   
04303                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
04304                       case 0: 
04305                         
04306                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
04307                             case 0: case 1: case 2: case 3: case 6: case 7: 
04308                               goto MATCH_label_a4; break;
04309                             case 4: 
04310                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
04311                               if ((MATCH_w_8_16 & 0x7) 
04312                                       /* base at 16 */ == 5 && 
04313                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04314                                       /* index at 16 */ && 
04315                                 (MATCH_w_8_16 >> 3 & 0x7) 
04316                                       /* index at 16 */ < 8)) 
04317                                 goto MATCH_label_a6;  /*opt-block+*/
04318                               else 
04319                                 goto MATCH_label_a5;  /*opt-block+*/
04320                               
04321                               break;
04322                             case 5: 
04323                               goto MATCH_label_a7; break;
04324                             default: assert(0);
04325                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
04326                         break;
04327                       case 1: 
04328                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
04329                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
04330                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04331                                 /* index at 16 */ && 
04332                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
04333                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
04334                           unsigned reg = 
04335                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
04336                           nextPC = 4 + MATCH_p; 
04337                           
04338                           #line 1192 "machine/pentium/disassembler.m"
04339                           
04340 
04341                                   sprintf (str,  "ADDmrod", DIS_EADDR32, DIS_REG32);
04342 
04343                           
04344 
04345                           
04346                           
04347                           
04348                         } /*opt-block*//*opt-block+*/
04349                         else 
04350                           goto MATCH_label_a5;  /*opt-block+*/
04351                         
04352                         break;
04353                       case 2: 
04354                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
04355                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
04356                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04357                                 /* index at 16 */ && 
04358                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
04359                           goto MATCH_label_a6;  /*opt-block+*/
04360                         else 
04361                           goto MATCH_label_a7;  /*opt-block+*/
04362                         
04363                         break;
04364                       case 3: 
04365                         goto MATCH_label_a4; break;
04366                       default: assert(0);
04367                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
04368                   
04369                   break;
04370                 case 2: 
04371                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
04372                   
04373                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
04374                       case 0: 
04375                         
04376                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
04377                             case 0: case 1: case 2: case 3: case 6: case 7: 
04378                               goto MATCH_label_a8; break;
04379                             case 4: 
04380                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
04381                               if ((MATCH_w_8_16 & 0x7) 
04382                                       /* base at 16 */ == 5 && 
04383                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04384                                       /* index at 16 */ && 
04385                                 (MATCH_w_8_16 >> 3 & 0x7) 
04386                                       /* index at 16 */ < 8)) 
04387                                 goto MATCH_label_a10;  /*opt-block+*/
04388                               else 
04389                                 goto MATCH_label_a9;  /*opt-block+*/
04390                               
04391                               break;
04392                             case 5: 
04393                               goto MATCH_label_a11; break;
04394                             default: assert(0);
04395                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
04396                         break;
04397                       case 1: 
04398                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
04399                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
04400                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04401                                 /* index at 16 */ && 
04402                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
04403                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
04404                           unsigned r8 = 
04405                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
04406                           nextPC = 4 + MATCH_p; 
04407                           
04408                           #line 1147 "machine/pentium/disassembler.m"
04409                           
04410 
04411                                   sprintf (str,  "ADDrmb", DIS_R8, DIS_EADDR8);
04412 
04413                           
04414 
04415                           
04416                           
04417                           
04418                         } /*opt-block*//*opt-block+*/
04419                         else 
04420                           goto MATCH_label_a9;  /*opt-block+*/
04421                         
04422                         break;
04423                       case 2: 
04424                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
04425                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
04426                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04427                                 /* index at 16 */ && 
04428                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
04429                           goto MATCH_label_a10;  /*opt-block+*/
04430                         else 
04431                           goto MATCH_label_a11;  /*opt-block+*/
04432                         
04433                         break;
04434                       case 3: 
04435                         goto MATCH_label_a8; break;
04436                       default: assert(0);
04437                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
04438                   
04439                   break;
04440                 case 3: 
04441                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
04442                   
04443                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
04444                       case 0: 
04445                         
04446                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
04447                             case 0: case 1: case 2: case 3: case 6: case 7: 
04448                               goto MATCH_label_a12; break;
04449                             case 4: 
04450                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
04451                               if ((MATCH_w_8_16 & 0x7) 
04452                                       /* base at 16 */ == 5 && 
04453                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04454                                       /* index at 16 */ && 
04455                                 (MATCH_w_8_16 >> 3 & 0x7) 
04456                                       /* index at 16 */ < 8)) 
04457                                 goto MATCH_label_a14;  /*opt-block+*/
04458                               else 
04459                                 goto MATCH_label_a13;  /*opt-block+*/
04460                               
04461                               break;
04462                             case 5: 
04463                               goto MATCH_label_a15; break;
04464                             default: assert(0);
04465                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
04466                         break;
04467                       case 1: 
04468                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
04469                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
04470                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04471                                 /* index at 16 */ && 
04472                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
04473                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
04474                           unsigned reg = 
04475                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
04476                           nextPC = 4 + MATCH_p; 
04477                           
04478                           #line 1120 "machine/pentium/disassembler.m"
04479                           
04480 
04481                                   sprintf (str,  "ADDrmod", DIS_REG32, DIS_EADDR32);
04482 
04483                           
04484 
04485                           
04486                           
04487                           
04488                         } /*opt-block*//*opt-block+*/
04489                         else 
04490                           goto MATCH_label_a13;  /*opt-block+*/
04491                         
04492                         break;
04493                       case 2: 
04494                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
04495                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
04496                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04497                                 /* index at 16 */ && 
04498                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
04499                           goto MATCH_label_a14;  /*opt-block+*/
04500                         else 
04501                           goto MATCH_label_a15;  /*opt-block+*/
04502                         
04503                         break;
04504                       case 3: 
04505                         goto MATCH_label_a12; break;
04506                       default: assert(0);
04507                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
04508                   
04509                   break;
04510                 case 4: 
04511                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
04512                   { 
04513                     int /* [~128..127] */ i8 = 
04514                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
04515                     nextPC = 2 + MATCH_p; 
04516                     
04517                     #line 1411 "machine/pentium/disassembler.m"
04518                     
04519 
04520                             sprintf (str,  "ADDiAL", DIS_I8);
04521 
04522                     
04523 
04524                     
04525                     
04526                     
04527                   }
04528                   
04529                   break;
04530                 case 5: 
04531                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
04532                   { 
04533                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
04534                     nextPC = 5 + MATCH_p; 
04535                     
04536                     #line 1363 "machine/pentium/disassembler.m"
04537                     
04538 
04539                             sprintf (str,  "ADDiEAX", DIS_I32);
04540 
04541                     
04542 
04543                     
04544                     
04545                     
04546                   }
04547                   
04548                   break;
04549                 case 6: 
04550                   nextPC = 1 + MATCH_p; 
04551                   
04552                   #line 513 "machine/pentium/disassembler.m"
04553                   
04554 
04555                           sprintf (str,  "PUSH.ES");
04556 
04557                   
04558 
04559                   
04560                   
04561                   
04562                   
04563                   break;
04564                 case 7: 
04565                   nextPC = 1 + MATCH_p; 
04566                   
04567                   #line 573 "machine/pentium/disassembler.m"
04568                   
04569 
04570                           sprintf (str,  "POP.ES");
04571 
04572                   
04573 
04574                   
04575                   
04576                   
04577                   
04578                   break;
04579                 default: assert(0);
04580               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/  
04581           break;
04582         case 1: 
04583           if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) 
04584             
04585               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
04586                 case 0: 
04587                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
04588                   
04589                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
04590                       case 0: 
04591                         
04592                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
04593                             case 0: case 1: case 2: case 3: case 6: case 7: 
04594                               goto MATCH_label_a193; break;
04595                             case 4: 
04596                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
04597                               if ((MATCH_w_8_16 & 0x7) 
04598                                       /* base at 16 */ == 5 && 
04599                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04600                                       /* index at 16 */ && 
04601                                 (MATCH_w_8_16 >> 3 & 0x7) 
04602                                       /* index at 16 */ < 8)) 
04603                                 goto MATCH_label_a195;  /*opt-block+*/
04604                               else 
04605                                 goto MATCH_label_a194;  /*opt-block+*/
04606                               
04607                               break;
04608                             case 5: 
04609                               goto MATCH_label_a196; break;
04610                             default: assert(0);
04611                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
04612                         break;
04613                       case 1: 
04614                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
04615                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
04616                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04617                                 /* index at 16 */ && 
04618                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
04619                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
04620                           unsigned r8 = 
04621                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
04622                           nextPC = 4 + MATCH_p; 
04623                           
04624                           #line 1210 "machine/pentium/disassembler.m"
04625                           
04626 
04627                                   sprintf (str,  "SBBmrb", DIS_EADDR8, DIS_R8);
04628 
04629                           
04630 
04631                           
04632                           
04633                           
04634                         } /*opt-block*//*opt-block+*/
04635                         else 
04636                           goto MATCH_label_a194;  /*opt-block+*/
04637                         
04638                         break;
04639                       case 2: 
04640                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
04641                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
04642                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04643                                 /* index at 16 */ && 
04644                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
04645                           goto MATCH_label_a195;  /*opt-block+*/
04646                         else 
04647                           goto MATCH_label_a196;  /*opt-block+*/
04648                         
04649                         break;
04650                       case 3: 
04651                         goto MATCH_label_a193; break;
04652                       default: assert(0);
04653                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
04654                   
04655                   break;
04656                 case 1: 
04657                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
04658                   
04659                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
04660                       case 0: 
04661                         
04662                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
04663                             case 0: case 1: case 2: case 3: case 6: case 7: 
04664                               goto MATCH_label_a197; break;
04665                             case 4: 
04666                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
04667                               if ((MATCH_w_8_16 & 0x7) 
04668                                       /* base at 16 */ == 5 && 
04669                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04670                                       /* index at 16 */ && 
04671                                 (MATCH_w_8_16 >> 3 & 0x7) 
04672                                       /* index at 16 */ < 8)) 
04673                                 goto MATCH_label_a199;  /*opt-block+*/
04674                               else 
04675                                 goto MATCH_label_a198;  /*opt-block+*/
04676                               
04677                               break;
04678                             case 5: 
04679                               goto MATCH_label_a200; break;
04680                             default: assert(0);
04681                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
04682                         break;
04683                       case 1: 
04684                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
04685                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
04686                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04687                                 /* index at 16 */ && 
04688                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
04689                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
04690                           unsigned reg = 
04691                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
04692                           nextPC = 4 + MATCH_p; 
04693                           
04694                           #line 1174 "machine/pentium/disassembler.m"
04695                           
04696 
04697                                   sprintf (str,  "SBBmrod", DIS_EADDR32, DIS_REG32);
04698 
04699                           
04700 
04701                           
04702                           
04703                           
04704                         } /*opt-block*//*opt-block+*/
04705                         else 
04706                           goto MATCH_label_a198;  /*opt-block+*/
04707                         
04708                         break;
04709                       case 2: 
04710                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
04711                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
04712                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04713                                 /* index at 16 */ && 
04714                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
04715                           goto MATCH_label_a199;  /*opt-block+*/
04716                         else 
04717                           goto MATCH_label_a200;  /*opt-block+*/
04718                         
04719                         break;
04720                       case 3: 
04721                         goto MATCH_label_a197; break;
04722                       default: assert(0);
04723                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
04724                   
04725                   break;
04726                 case 2: 
04727                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
04728                   
04729                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
04730                       case 0: 
04731                         
04732                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
04733                             case 0: case 1: case 2: case 3: case 6: case 7: 
04734                               goto MATCH_label_a201; break;
04735                             case 4: 
04736                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
04737                               if ((MATCH_w_8_16 & 0x7) 
04738                                       /* base at 16 */ == 5 && 
04739                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04740                                       /* index at 16 */ && 
04741                                 (MATCH_w_8_16 >> 3 & 0x7) 
04742                                       /* index at 16 */ < 8)) 
04743                                 goto MATCH_label_a203;  /*opt-block+*/
04744                               else 
04745                                 goto MATCH_label_a202;  /*opt-block+*/
04746                               
04747                               break;
04748                             case 5: 
04749                               goto MATCH_label_a204; break;
04750                             default: assert(0);
04751                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
04752                         break;
04753                       case 1: 
04754                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
04755                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
04756                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04757                                 /* index at 16 */ && 
04758                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
04759                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
04760                           unsigned r8 = 
04761                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
04762                           nextPC = 4 + MATCH_p; 
04763                           
04764                           #line 1138 "machine/pentium/disassembler.m"
04765                           
04766 
04767                                   sprintf (str,  "SBBrmb", DIS_R8, DIS_EADDR8);
04768 
04769                           
04770 
04771                           
04772                           
04773                           
04774                         } /*opt-block*//*opt-block+*/
04775                         else 
04776                           goto MATCH_label_a202;  /*opt-block+*/
04777                         
04778                         break;
04779                       case 2: 
04780                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
04781                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
04782                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04783                                 /* index at 16 */ && 
04784                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
04785                           goto MATCH_label_a203;  /*opt-block+*/
04786                         else 
04787                           goto MATCH_label_a204;  /*opt-block+*/
04788                         
04789                         break;
04790                       case 3: 
04791                         goto MATCH_label_a201; break;
04792                       default: assert(0);
04793                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
04794                   
04795                   break;
04796                 case 3: 
04797                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
04798                   
04799                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
04800                       case 0: 
04801                         
04802                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
04803                             case 0: case 1: case 2: case 3: case 6: case 7: 
04804                               goto MATCH_label_a205; break;
04805                             case 4: 
04806                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
04807                               if ((MATCH_w_8_16 & 0x7) 
04808                                       /* base at 16 */ == 5 && 
04809                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04810                                       /* index at 16 */ && 
04811                                 (MATCH_w_8_16 >> 3 & 0x7) 
04812                                       /* index at 16 */ < 8)) 
04813                                 goto MATCH_label_a207;  /*opt-block+*/
04814                               else 
04815                                 goto MATCH_label_a206;  /*opt-block+*/
04816                               
04817                               break;
04818                             case 5: 
04819                               goto MATCH_label_a208; break;
04820                             default: assert(0);
04821                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
04822                         break;
04823                       case 1: 
04824                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
04825                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
04826                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04827                                 /* index at 16 */ && 
04828                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
04829                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
04830                           unsigned reg = 
04831                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
04832                           nextPC = 4 + MATCH_p; 
04833                           
04834                           #line 1102 "machine/pentium/disassembler.m"
04835                           
04836 
04837                                   sprintf (str,  "SBBrmod", DIS_REG32, DIS_EADDR32);
04838 
04839                           
04840 
04841                           
04842                           
04843                           
04844                         } /*opt-block*//*opt-block+*/
04845                         else 
04846                           goto MATCH_label_a206;  /*opt-block+*/
04847                         
04848                         break;
04849                       case 2: 
04850                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
04851                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
04852                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04853                                 /* index at 16 */ && 
04854                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
04855                           goto MATCH_label_a207;  /*opt-block+*/
04856                         else 
04857                           goto MATCH_label_a208;  /*opt-block+*/
04858                         
04859                         break;
04860                       case 3: 
04861                         goto MATCH_label_a205; break;
04862                       default: assert(0);
04863                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
04864                   
04865                   break;
04866                 case 4: 
04867                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
04868                   { 
04869                     int /* [~128..127] */ i8 = 
04870                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
04871                     nextPC = 2 + MATCH_p; 
04872                     
04873                     #line 1402 "machine/pentium/disassembler.m"
04874                     
04875 
04876                             sprintf (str,  "SBBiAL", DIS_I8);
04877 
04878                     
04879 
04880                     
04881                     
04882                     
04883                   }
04884                   
04885                   break;
04886                 case 5: 
04887                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
04888                   { 
04889                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
04890                     nextPC = 5 + MATCH_p; 
04891                     
04892                     #line 1354 "machine/pentium/disassembler.m"
04893                     
04894 
04895                             sprintf (str,  "SBBiEAX", DIS_I32);
04896 
04897                     
04898 
04899                     
04900                     
04901                     
04902                   }
04903                   
04904                   break;
04905                 case 6: 
04906                   nextPC = 1 + MATCH_p; 
04907                   
04908                   #line 516 "machine/pentium/disassembler.m"
04909                   
04910 
04911                           sprintf (str,  "PUSH.DS");
04912 
04913                   
04914 
04915                   
04916                   
04917                   
04918                   
04919                   break;
04920                 case 7: 
04921                   nextPC = 1 + MATCH_p; 
04922                   
04923                   #line 567 "machine/pentium/disassembler.m"
04924                   
04925 
04926                           sprintf (str,  "POP.DS");
04927 
04928                   
04929 
04930                   
04931                   
04932                   
04933                   
04934                   break;
04935                 default: assert(0);
04936               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/  
04937           else 
04938             
04939               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
04940                 case 0: 
04941                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
04942                   
04943                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
04944                       case 0: 
04945                         
04946                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
04947                             case 0: case 1: case 2: case 3: case 6: case 7: 
04948                               goto MATCH_label_a177; break;
04949                             case 4: 
04950                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
04951                               if ((MATCH_w_8_16 & 0x7) 
04952                                       /* base at 16 */ == 5 && 
04953                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04954                                       /* index at 16 */ && 
04955                                 (MATCH_w_8_16 >> 3 & 0x7) 
04956                                       /* index at 16 */ < 8)) 
04957                                 goto MATCH_label_a179;  /*opt-block+*/
04958                               else 
04959                                 goto MATCH_label_a178;  /*opt-block+*/
04960                               
04961                               break;
04962                             case 5: 
04963                               goto MATCH_label_a180; break;
04964                             default: assert(0);
04965                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
04966                         break;
04967                       case 1: 
04968                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
04969                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
04970                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04971                                 /* index at 16 */ && 
04972                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
04973                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
04974                           unsigned r8 = 
04975                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
04976                           nextPC = 4 + MATCH_p; 
04977                           
04978                           #line 1213 "machine/pentium/disassembler.m"
04979                           
04980 
04981                                   sprintf (str,  "ADCmrb", DIS_EADDR8, DIS_R8);
04982 
04983                           
04984 
04985                           
04986                           
04987                           
04988                         } /*opt-block*//*opt-block+*/
04989                         else 
04990                           goto MATCH_label_a178;  /*opt-block+*/
04991                         
04992                         break;
04993                       case 2: 
04994                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
04995                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
04996                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
04997                                 /* index at 16 */ && 
04998                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
04999                           goto MATCH_label_a179;  /*opt-block+*/
05000                         else 
05001                           goto MATCH_label_a180;  /*opt-block+*/
05002                         
05003                         break;
05004                       case 3: 
05005                         goto MATCH_label_a177; break;
05006                       default: assert(0);
05007                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
05008                   
05009                   break;
05010                 case 1: 
05011                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
05012                   
05013                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
05014                       case 0: 
05015                         
05016                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
05017                             case 0: case 1: case 2: case 3: case 6: case 7: 
05018                               goto MATCH_label_a181; break;
05019                             case 4: 
05020                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
05021                               if ((MATCH_w_8_16 & 0x7) 
05022                                       /* base at 16 */ == 5 && 
05023                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05024                                       /* index at 16 */ && 
05025                                 (MATCH_w_8_16 >> 3 & 0x7) 
05026                                       /* index at 16 */ < 8)) 
05027                                 goto MATCH_label_a183;  /*opt-block+*/
05028                               else 
05029                                 goto MATCH_label_a182;  /*opt-block+*/
05030                               
05031                               break;
05032                             case 5: 
05033                               goto MATCH_label_a184; break;
05034                             default: assert(0);
05035                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
05036                         break;
05037                       case 1: 
05038                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05039                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05040                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05041                                 /* index at 16 */ && 
05042                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
05043                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
05044                           unsigned reg = 
05045                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
05046                           nextPC = 4 + MATCH_p; 
05047                           
05048                           #line 1180 "machine/pentium/disassembler.m"
05049                           
05050 
05051                                   sprintf (str,  "ADCmrod", DIS_EADDR32, DIS_REG32);
05052 
05053                           
05054 
05055                           
05056                           
05057                           
05058                         } /*opt-block*//*opt-block+*/
05059                         else 
05060                           goto MATCH_label_a182;  /*opt-block+*/
05061                         
05062                         break;
05063                       case 2: 
05064                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05065                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05066                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05067                                 /* index at 16 */ && 
05068                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
05069                           goto MATCH_label_a183;  /*opt-block+*/
05070                         else 
05071                           goto MATCH_label_a184;  /*opt-block+*/
05072                         
05073                         break;
05074                       case 3: 
05075                         goto MATCH_label_a181; break;
05076                       default: assert(0);
05077                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
05078                   
05079                   break;
05080                 case 2: 
05081                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
05082                   
05083                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
05084                       case 0: 
05085                         
05086                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
05087                             case 0: case 1: case 2: case 3: case 6: case 7: 
05088                               goto MATCH_label_a185; break;
05089                             case 4: 
05090                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
05091                               if ((MATCH_w_8_16 & 0x7) 
05092                                       /* base at 16 */ == 5 && 
05093                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05094                                       /* index at 16 */ && 
05095                                 (MATCH_w_8_16 >> 3 & 0x7) 
05096                                       /* index at 16 */ < 8)) 
05097                                 goto MATCH_label_a187;  /*opt-block+*/
05098                               else 
05099                                 goto MATCH_label_a186;  /*opt-block+*/
05100                               
05101                               break;
05102                             case 5: 
05103                               goto MATCH_label_a188; break;
05104                             default: assert(0);
05105                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
05106                         break;
05107                       case 1: 
05108                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05109                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05110                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05111                                 /* index at 16 */ && 
05112                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
05113                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
05114                           unsigned r8 = 
05115                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
05116                           nextPC = 4 + MATCH_p; 
05117                           
05118                           #line 1141 "machine/pentium/disassembler.m"
05119                           
05120 
05121                                   sprintf (str,  "ADCrmb", DIS_R8, DIS_EADDR8);
05122 
05123                           
05124 
05125                           
05126                           
05127                           
05128                         } /*opt-block*//*opt-block+*/
05129                         else 
05130                           goto MATCH_label_a186;  /*opt-block+*/
05131                         
05132                         break;
05133                       case 2: 
05134                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05135                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05136                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05137                                 /* index at 16 */ && 
05138                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
05139                           goto MATCH_label_a187;  /*opt-block+*/
05140                         else 
05141                           goto MATCH_label_a188;  /*opt-block+*/
05142                         
05143                         break;
05144                       case 3: 
05145                         goto MATCH_label_a185; break;
05146                       default: assert(0);
05147                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
05148                   
05149                   break;
05150                 case 3: 
05151                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
05152                   
05153                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
05154                       case 0: 
05155                         
05156                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
05157                             case 0: case 1: case 2: case 3: case 6: case 7: 
05158                               goto MATCH_label_a189; break;
05159                             case 4: 
05160                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
05161                               if ((MATCH_w_8_16 & 0x7) 
05162                                       /* base at 16 */ == 5 && 
05163                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05164                                       /* index at 16 */ && 
05165                                 (MATCH_w_8_16 >> 3 & 0x7) 
05166                                       /* index at 16 */ < 8)) 
05167                                 goto MATCH_label_a191;  /*opt-block+*/
05168                               else 
05169                                 goto MATCH_label_a190;  /*opt-block+*/
05170                               
05171                               break;
05172                             case 5: 
05173                               goto MATCH_label_a192; break;
05174                             default: assert(0);
05175                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
05176                         break;
05177                       case 1: 
05178                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05179                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05180                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05181                                 /* index at 16 */ && 
05182                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
05183                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
05184                           unsigned reg = 
05185                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
05186                           nextPC = 4 + MATCH_p; 
05187                           
05188                           #line 1108 "machine/pentium/disassembler.m"
05189                           
05190 
05191                                   sprintf (str,  "ADCrmod", DIS_REG32, DIS_EADDR32);
05192 
05193                           
05194 
05195                           
05196                           
05197                           
05198                         } /*opt-block*//*opt-block+*/
05199                         else 
05200                           goto MATCH_label_a190;  /*opt-block+*/
05201                         
05202                         break;
05203                       case 2: 
05204                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05205                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05206                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05207                                 /* index at 16 */ && 
05208                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
05209                           goto MATCH_label_a191;  /*opt-block+*/
05210                         else 
05211                           goto MATCH_label_a192;  /*opt-block+*/
05212                         
05213                         break;
05214                       case 3: 
05215                         goto MATCH_label_a189; break;
05216                       default: assert(0);
05217                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
05218                   
05219                   break;
05220                 case 4: 
05221                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
05222                   { 
05223                     int /* [~128..127] */ i8 = 
05224                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
05225                     nextPC = 2 + MATCH_p; 
05226                     
05227                     #line 1405 "machine/pentium/disassembler.m"
05228                     
05229 
05230                             sprintf (str,  "ADCiAL", DIS_I8);
05231 
05232                     
05233 
05234                     
05235                     
05236                     
05237                   }
05238                   
05239                   break;
05240                 case 5: 
05241                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
05242                   { 
05243                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
05244                     nextPC = 5 + MATCH_p; 
05245                     
05246                     #line 1357 "machine/pentium/disassembler.m"
05247                     
05248 
05249                             sprintf (str,  "ADCiEAX", DIS_I32);
05250 
05251                     
05252 
05253                     
05254                     
05255                     
05256                   }
05257                   
05258                   break;
05259                 case 6: 
05260                   nextPC = 1 + MATCH_p; 
05261                   
05262                   #line 519 "machine/pentium/disassembler.m"
05263                   
05264 
05265                           sprintf (str,  "PUSH.SS");
05266 
05267                   
05268 
05269                   
05270                   
05271                   
05272                   
05273                   break;
05274                 case 7: 
05275                   nextPC = 1 + MATCH_p; 
05276                   
05277                   #line 570 "machine/pentium/disassembler.m"
05278                   
05279 
05280                           sprintf (str,  "POP.SS");
05281 
05282                   
05283 
05284                   
05285                   
05286                   
05287                   
05288                   break;
05289                 default: assert(0);
05290               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/  
05291           break;
05292         case 2: 
05293           
05294             switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
05295               case 0: 
05296                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
05297                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
05298                   
05299                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
05300                       case 0: 
05301                         
05302                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
05303                             case 0: case 1: case 2: case 3: case 6: case 7: 
05304                               goto MATCH_label_a213; break;
05305                             case 4: 
05306                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
05307                               if ((MATCH_w_8_16 & 0x7) 
05308                                       /* base at 16 */ == 5 && 
05309                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05310                                       /* index at 16 */ && 
05311                                 (MATCH_w_8_16 >> 3 & 0x7) 
05312                                       /* index at 16 */ < 8)) 
05313                                 goto MATCH_label_a215;  /*opt-block+*/
05314                               else 
05315                                 goto MATCH_label_a214;  /*opt-block+*/
05316                               
05317                               break;
05318                             case 5: 
05319                               goto MATCH_label_a216; break;
05320                             default: assert(0);
05321                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
05322                         break;
05323                       case 1: 
05324                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05325                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05326                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05327                                 /* index at 16 */ && 
05328                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
05329                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
05330                           unsigned r8 = 
05331                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
05332                           nextPC = 4 + MATCH_p; 
05333                           
05334                           #line 1204 "machine/pentium/disassembler.m"
05335                           
05336 
05337                                   sprintf (str,  "SUBmrb", DIS_EADDR8, DIS_R8);
05338 
05339                           
05340 
05341                           
05342                           
05343                           
05344                         } /*opt-block*//*opt-block+*/
05345                         else 
05346                           goto MATCH_label_a214;  /*opt-block+*/
05347                         
05348                         break;
05349                       case 2: 
05350                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05351                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05352                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05353                                 /* index at 16 */ && 
05354                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
05355                           goto MATCH_label_a215;  /*opt-block+*/
05356                         else 
05357                           goto MATCH_label_a216;  /*opt-block+*/
05358                         
05359                         break;
05360                       case 3: 
05361                         goto MATCH_label_a213; break;
05362                       default: assert(0);
05363                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
05364                   
05365                 } /*opt-block*/
05366                 else { 
05367                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
05368                   
05369                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
05370                       case 0: 
05371                         
05372                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
05373                             case 0: case 1: case 2: case 3: case 6: case 7: 
05374                               goto MATCH_label_a209; break;
05375                             case 4: 
05376                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
05377                               if ((MATCH_w_8_16 & 0x7) 
05378                                       /* base at 16 */ == 5 && 
05379                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05380                                       /* index at 16 */ && 
05381                                 (MATCH_w_8_16 >> 3 & 0x7) 
05382                                       /* index at 16 */ < 8)) 
05383                                 goto MATCH_label_a211;  /*opt-block+*/
05384                               else 
05385                                 goto MATCH_label_a210;  /*opt-block+*/
05386                               
05387                               break;
05388                             case 5: 
05389                               goto MATCH_label_a212; break;
05390                             default: assert(0);
05391                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
05392                         break;
05393                       case 1: 
05394                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05395                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05396                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05397                                 /* index at 16 */ && 
05398                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
05399                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
05400                           unsigned r8 = 
05401                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
05402                           nextPC = 4 + MATCH_p; 
05403                           
05404                           #line 1207 "machine/pentium/disassembler.m"
05405                           
05406 
05407                                   sprintf (str,  "ANDmrb", DIS_EADDR8, DIS_R8);
05408 
05409                           
05410 
05411                           
05412                           
05413                           
05414                         } /*opt-block*//*opt-block+*/
05415                         else 
05416                           goto MATCH_label_a210;  /*opt-block+*/
05417                         
05418                         break;
05419                       case 2: 
05420                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05421                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05422                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05423                                 /* index at 16 */ && 
05424                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
05425                           goto MATCH_label_a211;  /*opt-block+*/
05426                         else 
05427                           goto MATCH_label_a212;  /*opt-block+*/
05428                         
05429                         break;
05430                       case 3: 
05431                         goto MATCH_label_a209; break;
05432                       default: assert(0);
05433                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
05434                   
05435                 } /*opt-block*/
05436                 break;
05437               case 1: 
05438                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
05439                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
05440                   
05441                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
05442                       case 0: 
05443                         
05444                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
05445                             case 0: case 1: case 2: case 3: case 6: case 7: 
05446                               goto MATCH_label_a221; break;
05447                             case 4: 
05448                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
05449                               if ((MATCH_w_8_16 & 0x7) 
05450                                       /* base at 16 */ == 5 && 
05451                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05452                                       /* index at 16 */ && 
05453                                 (MATCH_w_8_16 >> 3 & 0x7) 
05454                                       /* index at 16 */ < 8)) 
05455                                 goto MATCH_label_a223;  /*opt-block+*/
05456                               else 
05457                                 goto MATCH_label_a222;  /*opt-block+*/
05458                               
05459                               break;
05460                             case 5: 
05461                               goto MATCH_label_a224; break;
05462                             default: assert(0);
05463                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
05464                         break;
05465                       case 1: 
05466                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05467                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05468                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05469                                 /* index at 16 */ && 
05470                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
05471                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
05472                           unsigned reg = 
05473                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
05474                           nextPC = 4 + MATCH_p; 
05475                           
05476                           #line 1162 "machine/pentium/disassembler.m"
05477                           
05478 
05479                                   sprintf (str,  "SUBmrod", DIS_EADDR32, DIS_REG32);
05480 
05481                           
05482 
05483                           
05484                           
05485                           
05486                         } /*opt-block*//*opt-block+*/
05487                         else 
05488                           goto MATCH_label_a222;  /*opt-block+*/
05489                         
05490                         break;
05491                       case 2: 
05492                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05493                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05494                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05495                                 /* index at 16 */ && 
05496                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
05497                           goto MATCH_label_a223;  /*opt-block+*/
05498                         else 
05499                           goto MATCH_label_a224;  /*opt-block+*/
05500                         
05501                         break;
05502                       case 3: 
05503                         goto MATCH_label_a221; break;
05504                       default: assert(0);
05505                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
05506                   
05507                 } /*opt-block*/
05508                 else { 
05509                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
05510                   
05511                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
05512                       case 0: 
05513                         
05514                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
05515                             case 0: case 1: case 2: case 3: case 6: case 7: 
05516                               goto MATCH_label_a217; break;
05517                             case 4: 
05518                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
05519                               if ((MATCH_w_8_16 & 0x7) 
05520                                       /* base at 16 */ == 5 && 
05521                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05522                                       /* index at 16 */ && 
05523                                 (MATCH_w_8_16 >> 3 & 0x7) 
05524                                       /* index at 16 */ < 8)) 
05525                                 goto MATCH_label_a219;  /*opt-block+*/
05526                               else 
05527                                 goto MATCH_label_a218;  /*opt-block+*/
05528                               
05529                               break;
05530                             case 5: 
05531                               goto MATCH_label_a220; break;
05532                             default: assert(0);
05533                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
05534                         break;
05535                       case 1: 
05536                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05537                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05538                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05539                                 /* index at 16 */ && 
05540                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
05541                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
05542                           unsigned reg = 
05543                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
05544                           nextPC = 4 + MATCH_p; 
05545                           
05546                           #line 1168 "machine/pentium/disassembler.m"
05547                           
05548 
05549                                   sprintf (str,  "ANDmrod", DIS_EADDR32, DIS_REG32);
05550 
05551                           
05552 
05553                           
05554                           
05555                           
05556                         } /*opt-block*//*opt-block+*/
05557                         else 
05558                           goto MATCH_label_a218;  /*opt-block+*/
05559                         
05560                         break;
05561                       case 2: 
05562                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05563                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05564                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05565                                 /* index at 16 */ && 
05566                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
05567                           goto MATCH_label_a219;  /*opt-block+*/
05568                         else 
05569                           goto MATCH_label_a220;  /*opt-block+*/
05570                         
05571                         break;
05572                       case 3: 
05573                         goto MATCH_label_a217; break;
05574                       default: assert(0);
05575                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
05576                   
05577                 } /*opt-block*/
05578                 break;
05579               case 2: 
05580                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
05581                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
05582                   
05583                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
05584                       case 0: 
05585                         
05586                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
05587                             case 0: case 1: case 2: case 3: case 6: case 7: 
05588                               goto MATCH_label_a229; break;
05589                             case 4: 
05590                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
05591                               if ((MATCH_w_8_16 & 0x7) 
05592                                       /* base at 16 */ == 5 && 
05593                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05594                                       /* index at 16 */ && 
05595                                 (MATCH_w_8_16 >> 3 & 0x7) 
05596                                       /* index at 16 */ < 8)) 
05597                                 goto MATCH_label_a231;  /*opt-block+*/
05598                               else 
05599                                 goto MATCH_label_a230;  /*opt-block+*/
05600                               
05601                               break;
05602                             case 5: 
05603                               goto MATCH_label_a232; break;
05604                             default: assert(0);
05605                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
05606                         break;
05607                       case 1: 
05608                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05609                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05610                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05611                                 /* index at 16 */ && 
05612                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
05613                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
05614                           unsigned r8 = 
05615                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
05616                           nextPC = 4 + MATCH_p; 
05617                           
05618                           #line 1132 "machine/pentium/disassembler.m"
05619                           
05620 
05621                                   sprintf (str,  "SUBrmb", DIS_R8, DIS_EADDR8);
05622 
05623                           
05624 
05625                           
05626                           
05627                           
05628                         } /*opt-block*//*opt-block+*/
05629                         else 
05630                           goto MATCH_label_a230;  /*opt-block+*/
05631                         
05632                         break;
05633                       case 2: 
05634                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05635                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05636                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05637                                 /* index at 16 */ && 
05638                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
05639                           goto MATCH_label_a231;  /*opt-block+*/
05640                         else 
05641                           goto MATCH_label_a232;  /*opt-block+*/
05642                         
05643                         break;
05644                       case 3: 
05645                         goto MATCH_label_a229; break;
05646                       default: assert(0);
05647                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
05648                   
05649                 } /*opt-block*/
05650                 else { 
05651                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
05652                   
05653                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
05654                       case 0: 
05655                         
05656                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
05657                             case 0: case 1: case 2: case 3: case 6: case 7: 
05658                               goto MATCH_label_a225; break;
05659                             case 4: 
05660                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
05661                               if ((MATCH_w_8_16 & 0x7) 
05662                                       /* base at 16 */ == 5 && 
05663                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05664                                       /* index at 16 */ && 
05665                                 (MATCH_w_8_16 >> 3 & 0x7) 
05666                                       /* index at 16 */ < 8)) 
05667                                 goto MATCH_label_a227;  /*opt-block+*/
05668                               else 
05669                                 goto MATCH_label_a226;  /*opt-block+*/
05670                               
05671                               break;
05672                             case 5: 
05673                               goto MATCH_label_a228; break;
05674                             default: assert(0);
05675                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
05676                         break;
05677                       case 1: 
05678                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05679                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05680                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05681                                 /* index at 16 */ && 
05682                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
05683                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
05684                           unsigned r8 = 
05685                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
05686                           nextPC = 4 + MATCH_p; 
05687                           
05688                           #line 1135 "machine/pentium/disassembler.m"
05689                           
05690 
05691                                   sprintf (str,  "ANDrmb", DIS_R8, DIS_EADDR8);
05692 
05693                           
05694 
05695                           
05696                           
05697                           
05698                         } /*opt-block*//*opt-block+*/
05699                         else 
05700                           goto MATCH_label_a226;  /*opt-block+*/
05701                         
05702                         break;
05703                       case 2: 
05704                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05705                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05706                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05707                                 /* index at 16 */ && 
05708                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
05709                           goto MATCH_label_a227;  /*opt-block+*/
05710                         else 
05711                           goto MATCH_label_a228;  /*opt-block+*/
05712                         
05713                         break;
05714                       case 3: 
05715                         goto MATCH_label_a225; break;
05716                       default: assert(0);
05717                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
05718                   
05719                 } /*opt-block*/
05720                 break;
05721               case 3: 
05722                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
05723                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
05724                   
05725                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
05726                       case 0: 
05727                         
05728                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
05729                             case 0: case 1: case 2: case 3: case 6: case 7: 
05730                               goto MATCH_label_a237; break;
05731                             case 4: 
05732                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
05733                               if ((MATCH_w_8_16 & 0x7) 
05734                                       /* base at 16 */ == 5 && 
05735                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05736                                       /* index at 16 */ && 
05737                                 (MATCH_w_8_16 >> 3 & 0x7) 
05738                                       /* index at 16 */ < 8)) 
05739                                 goto MATCH_label_a239;  /*opt-block+*/
05740                               else 
05741                                 goto MATCH_label_a238;  /*opt-block+*/
05742                               
05743                               break;
05744                             case 5: 
05745                               goto MATCH_label_a240; break;
05746                             default: assert(0);
05747                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
05748                         break;
05749                       case 1: 
05750                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05751                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05752                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05753                                 /* index at 16 */ && 
05754                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
05755                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
05756                           unsigned reg = 
05757                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
05758                           nextPC = 4 + MATCH_p; 
05759                           
05760                           #line 1090 "machine/pentium/disassembler.m"
05761                           
05762 
05763                                   sprintf (str,  "SUBrmod", DIS_REG32, DIS_EADDR32);
05764 
05765                           
05766 
05767                           
05768                           
05769                           
05770                         } /*opt-block*//*opt-block+*/
05771                         else 
05772                           goto MATCH_label_a238;  /*opt-block+*/
05773                         
05774                         break;
05775                       case 2: 
05776                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05777                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05778                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05779                                 /* index at 16 */ && 
05780                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
05781                           goto MATCH_label_a239;  /*opt-block+*/
05782                         else 
05783                           goto MATCH_label_a240;  /*opt-block+*/
05784                         
05785                         break;
05786                       case 3: 
05787                         goto MATCH_label_a237; break;
05788                       default: assert(0);
05789                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
05790                   
05791                 } /*opt-block*/
05792                 else { 
05793                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
05794                   
05795                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
05796                       case 0: 
05797                         
05798                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
05799                             case 0: case 1: case 2: case 3: case 6: case 7: 
05800                               goto MATCH_label_a233; break;
05801                             case 4: 
05802                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
05803                               if ((MATCH_w_8_16 & 0x7) 
05804                                       /* base at 16 */ == 5 && 
05805                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05806                                       /* index at 16 */ && 
05807                                 (MATCH_w_8_16 >> 3 & 0x7) 
05808                                       /* index at 16 */ < 8)) 
05809                                 goto MATCH_label_a235;  /*opt-block+*/
05810                               else 
05811                                 goto MATCH_label_a234;  /*opt-block+*/
05812                               
05813                               break;
05814                             case 5: 
05815                               goto MATCH_label_a236; break;
05816                             default: assert(0);
05817                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
05818                         break;
05819                       case 1: 
05820                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05821                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05822                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05823                                 /* index at 16 */ && 
05824                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
05825                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
05826                           unsigned reg = 
05827                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
05828                           nextPC = 4 + MATCH_p; 
05829                           
05830                           #line 1096 "machine/pentium/disassembler.m"
05831                           
05832 
05833                                   sprintf (str,  "ANDrmod", DIS_REG32, DIS_EADDR32);
05834 
05835                           
05836 
05837                           
05838                           
05839                           
05840                         } /*opt-block*//*opt-block+*/
05841                         else 
05842                           goto MATCH_label_a234;  /*opt-block+*/
05843                         
05844                         break;
05845                       case 2: 
05846                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
05847                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
05848                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
05849                                 /* index at 16 */ && 
05850                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
05851                           goto MATCH_label_a235;  /*opt-block+*/
05852                         else 
05853                           goto MATCH_label_a236;  /*opt-block+*/
05854                         
05855                         break;
05856                       case 3: 
05857                         goto MATCH_label_a233; break;
05858                       default: assert(0);
05859                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
05860                   
05861                 } /*opt-block*/
05862                 break;
05863               case 4: 
05864                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
05865                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
05866                   { 
05867                     int /* [~128..127] */ i8 = 
05868                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
05869                     nextPC = 2 + MATCH_p; 
05870                     
05871                     #line 1396 "machine/pentium/disassembler.m"
05872                     
05873 
05874                             sprintf (str,  "SUBiAL", DIS_I8);
05875 
05876                     
05877 
05878                     
05879                     
05880                     
05881                   }
05882                   
05883                 } /*opt-block*/
05884                 else { 
05885                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
05886                   { 
05887                     int /* [~128..127] */ i8 = 
05888                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
05889                     nextPC = 2 + MATCH_p; 
05890                     
05891                     #line 1399 "machine/pentium/disassembler.m"
05892                     
05893 
05894                             sprintf (str,  "ANDiAL", DIS_I8);
05895 
05896                     
05897 
05898                     
05899                     
05900                     
05901                   }
05902                   
05903                 } /*opt-block*/
05904                 
05905                 break;
05906               case 5: 
05907                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
05908                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
05909                   { 
05910                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
05911                     nextPC = 5 + MATCH_p; 
05912                     
05913                     #line 1348 "machine/pentium/disassembler.m"
05914                     
05915 
05916                             sprintf (str,  "SUBiEAX", DIS_I32);
05917 
05918                     
05919 
05920                     
05921                     
05922                     
05923                   }
05924                   
05925                 } /*opt-block*/
05926                 else { 
05927                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
05928                   { 
05929                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
05930                     nextPC = 5 + MATCH_p; 
05931                     
05932                     #line 1351 "machine/pentium/disassembler.m"
05933                     
05934 
05935                             sprintf (str,  "ANDiEAX", DIS_I32);
05936 
05937                     
05938 
05939                     
05940                     
05941                     
05942                   }
05943                   
05944                 } /*opt-block*/
05945                 
05946                 break;
05947               case 6: 
05948                 goto MATCH_label_a39; break;
05949               case 7: 
05950                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
05951                   nextPC = 1 + MATCH_p; 
05952                   
05953                   #line 923 "machine/pentium/disassembler.m"
05954                   
05955 
05956                           sprintf (str,  "DAS");
05957 
05958                   
05959 
05960                   
05961                   
05962                   
05963                 } /*opt-block*//*opt-block+*/
05964                 else { 
05965                   nextPC = 1 + MATCH_p; 
05966                   
05967                   #line 926 "machine/pentium/disassembler.m"
05968                   
05969 
05970                           sprintf (str,  "DAA");
05971 
05972                   
05973 
05974                   
05975                   
05976                   
05977                 } /*opt-block*//*opt-block+*/
05978                 
05979                 break;
05980               default: assert(0);
05981             } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
05982           break;
05983         case 3: 
05984           
05985             switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
05986               case 0: 
05987                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
05988                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
05989                   
05990                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
05991                       case 0: 
05992                         
05993                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
05994                             case 0: case 1: case 2: case 3: case 6: case 7: 
05995                               goto MATCH_label_a245; break;
05996                             case 4: 
05997                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
05998                               if ((MATCH_w_8_16 & 0x7) 
05999                                       /* base at 16 */ == 5 && 
06000                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06001                                       /* index at 16 */ && 
06002                                 (MATCH_w_8_16 >> 3 & 0x7) 
06003                                       /* index at 16 */ < 8)) 
06004                                 goto MATCH_label_a247;  /*opt-block+*/
06005                               else 
06006                                 goto MATCH_label_a246;  /*opt-block+*/
06007                               
06008                               break;
06009                             case 5: 
06010                               goto MATCH_label_a248; break;
06011                             default: assert(0);
06012                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06013                         break;
06014                       case 1: 
06015                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06016                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06017                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06018                                 /* index at 16 */ && 
06019                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06020                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06021                           unsigned r8 = 
06022                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06023                           nextPC = 4 + MATCH_p; 
06024                           
06025                           #line 1198 "machine/pentium/disassembler.m"
06026                           
06027 
06028                                   sprintf (str,  "CMPmrb", DIS_EADDR8, DIS_R8);
06029 
06030                           
06031 
06032                           
06033                           
06034                           
06035                         } /*opt-block*//*opt-block+*/
06036                         else 
06037                           goto MATCH_label_a246;  /*opt-block+*/
06038                         
06039                         break;
06040                       case 2: 
06041                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06042                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06043                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06044                                 /* index at 16 */ && 
06045                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06046                           goto MATCH_label_a247;  /*opt-block+*/
06047                         else 
06048                           goto MATCH_label_a248;  /*opt-block+*/
06049                         
06050                         break;
06051                       case 3: 
06052                         goto MATCH_label_a245; break;
06053                       default: assert(0);
06054                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06055                   
06056                 } /*opt-block*/
06057                 else { 
06058                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06059                   
06060                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06061                       case 0: 
06062                         
06063                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06064                             case 0: case 1: case 2: case 3: case 6: case 7: 
06065                               goto MATCH_label_a241; break;
06066                             case 4: 
06067                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06068                               if ((MATCH_w_8_16 & 0x7) 
06069                                       /* base at 16 */ == 5 && 
06070                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06071                                       /* index at 16 */ && 
06072                                 (MATCH_w_8_16 >> 3 & 0x7) 
06073                                       /* index at 16 */ < 8)) 
06074                                 goto MATCH_label_a243;  /*opt-block+*/
06075                               else 
06076                                 goto MATCH_label_a242;  /*opt-block+*/
06077                               
06078                               break;
06079                             case 5: 
06080                               goto MATCH_label_a244; break;
06081                             default: assert(0);
06082                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06083                         break;
06084                       case 1: 
06085                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06086                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06087                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06088                                 /* index at 16 */ && 
06089                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06090                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06091                           unsigned r8 = 
06092                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06093                           nextPC = 4 + MATCH_p; 
06094                           
06095                           #line 1201 "machine/pentium/disassembler.m"
06096                           
06097 
06098                                   sprintf (str,  "XORmrb", DIS_EADDR8, DIS_R8);
06099 
06100                           
06101 
06102                           
06103                           
06104                           
06105                         } /*opt-block*//*opt-block+*/
06106                         else 
06107                           goto MATCH_label_a242;  /*opt-block+*/
06108                         
06109                         break;
06110                       case 2: 
06111                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06112                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06113                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06114                                 /* index at 16 */ && 
06115                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06116                           goto MATCH_label_a243;  /*opt-block+*/
06117                         else 
06118                           goto MATCH_label_a244;  /*opt-block+*/
06119                         
06120                         break;
06121                       case 3: 
06122                         goto MATCH_label_a241; break;
06123                       default: assert(0);
06124                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06125                   
06126                 } /*opt-block*/
06127                 break;
06128               case 1: 
06129                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
06130                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06131                   
06132                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06133                       case 0: 
06134                         
06135                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06136                             case 0: case 1: case 2: case 3: case 6: case 7: 
06137                               goto MATCH_label_a253; break;
06138                             case 4: 
06139                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06140                               if ((MATCH_w_8_16 & 0x7) 
06141                                       /* base at 16 */ == 5 && 
06142                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06143                                       /* index at 16 */ && 
06144                                 (MATCH_w_8_16 >> 3 & 0x7) 
06145                                       /* index at 16 */ < 8)) 
06146                                 goto MATCH_label_a255;  /*opt-block+*/
06147                               else 
06148                                 goto MATCH_label_a254;  /*opt-block+*/
06149                               
06150                               break;
06151                             case 5: 
06152                               goto MATCH_label_a256; break;
06153                             default: assert(0);
06154                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06155                         break;
06156                       case 1: 
06157                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06158                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06159                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06160                                 /* index at 16 */ && 
06161                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06162                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06163                           unsigned reg = 
06164                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06165                           nextPC = 4 + MATCH_p; 
06166                           
06167                           #line 1150 "machine/pentium/disassembler.m"
06168                           
06169 
06170                                   sprintf (str,  "CMPmrod", DIS_EADDR32, DIS_REG32);
06171 
06172                           
06173 
06174                           
06175                           
06176                           
06177                         } /*opt-block*//*opt-block+*/
06178                         else 
06179                           goto MATCH_label_a254;  /*opt-block+*/
06180                         
06181                         break;
06182                       case 2: 
06183                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06184                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06185                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06186                                 /* index at 16 */ && 
06187                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06188                           goto MATCH_label_a255;  /*opt-block+*/
06189                         else 
06190                           goto MATCH_label_a256;  /*opt-block+*/
06191                         
06192                         break;
06193                       case 3: 
06194                         goto MATCH_label_a253; break;
06195                       default: assert(0);
06196                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06197                   
06198                 } /*opt-block*/
06199                 else { 
06200                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06201                   
06202                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06203                       case 0: 
06204                         
06205                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06206                             case 0: case 1: case 2: case 3: case 6: case 7: 
06207                               goto MATCH_label_a249; break;
06208                             case 4: 
06209                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06210                               if ((MATCH_w_8_16 & 0x7) 
06211                                       /* base at 16 */ == 5 && 
06212                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06213                                       /* index at 16 */ && 
06214                                 (MATCH_w_8_16 >> 3 & 0x7) 
06215                                       /* index at 16 */ < 8)) 
06216                                 goto MATCH_label_a251;  /*opt-block+*/
06217                               else 
06218                                 goto MATCH_label_a250;  /*opt-block+*/
06219                               
06220                               break;
06221                             case 5: 
06222                               goto MATCH_label_a252; break;
06223                             default: assert(0);
06224                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06225                         break;
06226                       case 1: 
06227                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06228                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06229                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06230                                 /* index at 16 */ && 
06231                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06232                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06233                           unsigned reg = 
06234                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06235                           nextPC = 4 + MATCH_p; 
06236                           
06237                           #line 1156 "machine/pentium/disassembler.m"
06238                           
06239 
06240                                   sprintf (str,  "XORmrod", DIS_EADDR32, DIS_REG32);
06241 
06242                           
06243 
06244                           
06245                           
06246                           
06247                         } /*opt-block*//*opt-block+*/
06248                         else 
06249                           goto MATCH_label_a250;  /*opt-block+*/
06250                         
06251                         break;
06252                       case 2: 
06253                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06254                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06255                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06256                                 /* index at 16 */ && 
06257                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06258                           goto MATCH_label_a251;  /*opt-block+*/
06259                         else 
06260                           goto MATCH_label_a252;  /*opt-block+*/
06261                         
06262                         break;
06263                       case 3: 
06264                         goto MATCH_label_a249; break;
06265                       default: assert(0);
06266                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06267                   
06268                 } /*opt-block*/
06269                 break;
06270               case 2: 
06271                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
06272                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06273                   
06274                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06275                       case 0: 
06276                         
06277                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06278                             case 0: case 1: case 2: case 3: case 6: case 7: 
06279                               goto MATCH_label_a261; break;
06280                             case 4: 
06281                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06282                               if ((MATCH_w_8_16 & 0x7) 
06283                                       /* base at 16 */ == 5 && 
06284                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06285                                       /* index at 16 */ && 
06286                                 (MATCH_w_8_16 >> 3 & 0x7) 
06287                                       /* index at 16 */ < 8)) 
06288                                 goto MATCH_label_a263;  /*opt-block+*/
06289                               else 
06290                                 goto MATCH_label_a262;  /*opt-block+*/
06291                               
06292                               break;
06293                             case 5: 
06294                               goto MATCH_label_a264; break;
06295                             default: assert(0);
06296                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06297                         break;
06298                       case 1: 
06299                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06300                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06301                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06302                                 /* index at 16 */ && 
06303                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06304                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06305                           unsigned r8 = 
06306                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06307                           nextPC = 4 + MATCH_p; 
06308                           
06309                           #line 1126 "machine/pentium/disassembler.m"
06310                           
06311 
06312                                   sprintf (str,  "CMPrmb", DIS_R8, DIS_EADDR8);
06313 
06314                           
06315 
06316                           
06317                           
06318                           
06319                         } /*opt-block*//*opt-block+*/
06320                         else 
06321                           goto MATCH_label_a262;  /*opt-block+*/
06322                         
06323                         break;
06324                       case 2: 
06325                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06326                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06327                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06328                                 /* index at 16 */ && 
06329                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06330                           goto MATCH_label_a263;  /*opt-block+*/
06331                         else 
06332                           goto MATCH_label_a264;  /*opt-block+*/
06333                         
06334                         break;
06335                       case 3: 
06336                         goto MATCH_label_a261; break;
06337                       default: assert(0);
06338                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06339                   
06340                 } /*opt-block*/
06341                 else { 
06342                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06343                   
06344                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06345                       case 0: 
06346                         
06347                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06348                             case 0: case 1: case 2: case 3: case 6: case 7: 
06349                               goto MATCH_label_a257; break;
06350                             case 4: 
06351                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06352                               if ((MATCH_w_8_16 & 0x7) 
06353                                       /* base at 16 */ == 5 && 
06354                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06355                                       /* index at 16 */ && 
06356                                 (MATCH_w_8_16 >> 3 & 0x7) 
06357                                       /* index at 16 */ < 8)) 
06358                                 goto MATCH_label_a259;  /*opt-block+*/
06359                               else 
06360                                 goto MATCH_label_a258;  /*opt-block+*/
06361                               
06362                               break;
06363                             case 5: 
06364                               goto MATCH_label_a260; break;
06365                             default: assert(0);
06366                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06367                         break;
06368                       case 1: 
06369                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06370                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06371                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06372                                 /* index at 16 */ && 
06373                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06374                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06375                           unsigned r8 = 
06376                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06377                           nextPC = 4 + MATCH_p; 
06378                           
06379                           #line 1129 "machine/pentium/disassembler.m"
06380                           
06381 
06382                                   sprintf (str,  "XORrmb", DIS_R8, DIS_EADDR8);
06383 
06384                           
06385 
06386                           
06387                           
06388                           
06389                         } /*opt-block*//*opt-block+*/
06390                         else 
06391                           goto MATCH_label_a258;  /*opt-block+*/
06392                         
06393                         break;
06394                       case 2: 
06395                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06396                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06397                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06398                                 /* index at 16 */ && 
06399                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06400                           goto MATCH_label_a259;  /*opt-block+*/
06401                         else 
06402                           goto MATCH_label_a260;  /*opt-block+*/
06403                         
06404                         break;
06405                       case 3: 
06406                         goto MATCH_label_a257; break;
06407                       default: assert(0);
06408                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06409                   
06410                 } /*opt-block*/
06411                 break;
06412               case 3: 
06413                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
06414                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06415                   
06416                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06417                       case 0: 
06418                         
06419                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06420                             case 0: case 1: case 2: case 3: case 6: case 7: 
06421                               goto MATCH_label_a269; break;
06422                             case 4: 
06423                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06424                               if ((MATCH_w_8_16 & 0x7) 
06425                                       /* base at 16 */ == 5 && 
06426                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06427                                       /* index at 16 */ && 
06428                                 (MATCH_w_8_16 >> 3 & 0x7) 
06429                                       /* index at 16 */ < 8)) 
06430                                 goto MATCH_label_a271;  /*opt-block+*/
06431                               else 
06432                                 goto MATCH_label_a270;  /*opt-block+*/
06433                               
06434                               break;
06435                             case 5: 
06436                               goto MATCH_label_a272; break;
06437                             default: assert(0);
06438                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06439                         break;
06440                       case 1: 
06441                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06442                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06443                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06444                                 /* index at 16 */ && 
06445                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06446                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06447                           unsigned reg = 
06448                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06449                           nextPC = 4 + MATCH_p; 
06450                           
06451                           #line 1078 "machine/pentium/disassembler.m"
06452                           
06453 
06454                                   sprintf (str,  "CMPrmod", DIS_REG32, DIS_EADDR32);
06455 
06456                           
06457 
06458                           
06459                           
06460                           
06461                         } /*opt-block*//*opt-block+*/
06462                         else 
06463                           goto MATCH_label_a270;  /*opt-block+*/
06464                         
06465                         break;
06466                       case 2: 
06467                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06468                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06469                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06470                                 /* index at 16 */ && 
06471                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06472                           goto MATCH_label_a271;  /*opt-block+*/
06473                         else 
06474                           goto MATCH_label_a272;  /*opt-block+*/
06475                         
06476                         break;
06477                       case 3: 
06478                         goto MATCH_label_a269; break;
06479                       default: assert(0);
06480                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06481                   
06482                 } /*opt-block*/
06483                 else { 
06484                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06485                   
06486                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06487                       case 0: 
06488                         
06489                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06490                             case 0: case 1: case 2: case 3: case 6: case 7: 
06491                               goto MATCH_label_a265; break;
06492                             case 4: 
06493                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06494                               if ((MATCH_w_8_16 & 0x7) 
06495                                       /* base at 16 */ == 5 && 
06496                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06497                                       /* index at 16 */ && 
06498                                 (MATCH_w_8_16 >> 3 & 0x7) 
06499                                       /* index at 16 */ < 8)) 
06500                                 goto MATCH_label_a267;  /*opt-block+*/
06501                               else 
06502                                 goto MATCH_label_a266;  /*opt-block+*/
06503                               
06504                               break;
06505                             case 5: 
06506                               goto MATCH_label_a268; break;
06507                             default: assert(0);
06508                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06509                         break;
06510                       case 1: 
06511                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06512                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06513                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06514                                 /* index at 16 */ && 
06515                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06516                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
06517                           unsigned reg = 
06518                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06519                           nextPC = 4 + MATCH_p; 
06520                           
06521                           #line 1084 "machine/pentium/disassembler.m"
06522                           
06523 
06524                                   sprintf (str,  "XORrmod", DIS_REG32, DIS_EADDR32);
06525 
06526                           
06527 
06528                           
06529                           
06530                           
06531                         } /*opt-block*//*opt-block+*/
06532                         else 
06533                           goto MATCH_label_a266;  /*opt-block+*/
06534                         
06535                         break;
06536                       case 2: 
06537                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06538                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06539                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06540                                 /* index at 16 */ && 
06541                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
06542                           goto MATCH_label_a267;  /*opt-block+*/
06543                         else 
06544                           goto MATCH_label_a268;  /*opt-block+*/
06545                         
06546                         break;
06547                       case 3: 
06548                         goto MATCH_label_a265; break;
06549                       default: assert(0);
06550                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06551                   
06552                 } /*opt-block*/
06553                 break;
06554               case 4: 
06555                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
06556                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06557                   { 
06558                     int /* [~128..127] */ i8 = 
06559                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
06560                     nextPC = 2 + MATCH_p; 
06561                     
06562                     #line 1390 "machine/pentium/disassembler.m"
06563                     
06564 
06565                             sprintf (str,  "CMPiAL", DIS_I8);
06566 
06567                     
06568 
06569                     
06570                     
06571                     
06572                   }
06573                   
06574                 } /*opt-block*/
06575                 else { 
06576                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06577                   { 
06578                     int /* [~128..127] */ i8 = 
06579                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
06580                     nextPC = 2 + MATCH_p; 
06581                     
06582                     #line 1393 "machine/pentium/disassembler.m"
06583                     
06584 
06585                             sprintf (str,  "XORiAL", DIS_I8);
06586 
06587                     
06588 
06589                     
06590                     
06591                     
06592                   }
06593                   
06594                 } /*opt-block*/
06595                 
06596                 break;
06597               case 5: 
06598                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
06599                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
06600                   { 
06601                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
06602                     nextPC = 5 + MATCH_p; 
06603                     
06604                     #line 1342 "machine/pentium/disassembler.m"
06605                     
06606 
06607                             sprintf (str,  "CMPiEAX", DIS_I32);
06608 
06609                     
06610 
06611                     
06612                     
06613                     
06614                   }
06615                   
06616                 } /*opt-block*/
06617                 else { 
06618                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
06619                   { 
06620                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
06621                     nextPC = 5 + MATCH_p; 
06622                     
06623                     #line 1345 "machine/pentium/disassembler.m"
06624                     
06625 
06626                             sprintf (str,  "XORiEAX", DIS_I32);
06627 
06628                     
06629 
06630                     
06631                     
06632                     
06633                   }
06634                   
06635                 } /*opt-block*/
06636                 
06637                 break;
06638               case 6: case 7: 
06639                 goto MATCH_label_a39; break;
06640               default: assert(0);
06641             } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
06642           break;
06643         case 4: 
06644           if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
06645             unsigned r32 = (MATCH_w_8_0 & 0x7) /* r32 at 0 */;
06646             nextPC = 1 + MATCH_p; 
06647             
06648             #line 908 "machine/pentium/disassembler.m"
06649             
06650 
06651                     sprintf (str,  "DECod", DIS_R32);
06652 
06653             
06654 
06655             
06656             
06657             
06658           } /*opt-block*//*opt-block+*/
06659           else { 
06660             unsigned r32 = (MATCH_w_8_0 & 0x7) /* r32 at 0 */;
06661             nextPC = 1 + MATCH_p; 
06662             
06663             #line 824 "machine/pentium/disassembler.m"
06664             
06665 
06666                     sprintf (str,  "INCod", DIS_R32);
06667 
06668             
06669 
06670             
06671             
06672             
06673           } /*opt-block*//*opt-block+*/
06674           
06675           break;
06676         case 5: 
06677           if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
06678             unsigned r32 = (MATCH_w_8_0 & 0x7) /* r32 at 0 */;
06679             nextPC = 1 + MATCH_p; 
06680             
06681             #line 576 "machine/pentium/disassembler.m"
06682             
06683 
06684                     sprintf (str,  "POPod", DIS_R32);
06685 
06686             
06687 
06688             
06689             
06690             
06691           } /*opt-block*//*opt-block+*/
06692           else { 
06693             unsigned r32 = (MATCH_w_8_0 & 0x7) /* r32 at 0 */;
06694             nextPC = 1 + MATCH_p; 
06695             
06696             #line 537 "machine/pentium/disassembler.m"
06697             
06698 
06699                     sprintf (str,  "PUSHod", DIS_R32);
06700 
06701             
06702 
06703             
06704             
06705             
06706           } /*opt-block*//*opt-block+*/
06707           
06708           break;
06709         case 6: 
06710           
06711             switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
06712               case 0: 
06713                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
06714                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
06715                   { 
06716                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
06717                     nextPC = 5 + MATCH_p; 
06718                     
06719                     #line 525 "machine/pentium/disassembler.m"
06720                     
06721 
06722                             sprintf (str,  "PUSH.Ivod", DIS_I32);
06723 
06724                     
06725 
06726                     
06727                     
06728                     
06729                   }
06730                   
06731                 } /*opt-block*/
06732                 else 
06733                   goto MATCH_label_a39;  /*opt-block+*/
06734                 
06735                 break;
06736               case 1: 
06737                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
06738                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06739                   
06740                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06741                       case 0: 
06742                         
06743                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06744                             case 0: case 1: case 2: case 3: case 6: case 7: 
06745                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
06746                               goto MATCH_label_a273; 
06747                               
06748                               break;
06749                             case 4: 
06750                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06751                               if ((MATCH_w_8_16 & 0x7) 
06752                                       /* base at 16 */ == 5 && 
06753                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06754                                       /* index at 16 */ && 
06755                                 (MATCH_w_8_16 >> 3 & 0x7) 
06756                                       /* index at 16 */ < 8)) { 
06757                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
06758                                 goto MATCH_label_a275; 
06759                                 
06760                               } /*opt-block*/
06761                               else { 
06762                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
06763                                 goto MATCH_label_a274; 
06764                                 
06765                               } /*opt-block*/
06766                               
06767                               break;
06768                             case 5: 
06769                               MATCH_w_32_48 = getDword(6 + MATCH_p); 
06770                               goto MATCH_label_a276; 
06771                               
06772                               break;
06773                             default: assert(0);
06774                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06775                         break;
06776                       case 1: 
06777                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06778                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06779                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06780                                 /* index at 16 */ && 
06781                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06782                           MATCH_w_32_32 = getDword(4 + MATCH_p); 
06783                           { 
06784                             unsigned Eaddr = 1 + addressToPC(MATCH_p);
06785                             unsigned i32 = MATCH_w_32_32 /* i32 at 32 */;
06786                             unsigned reg = 
06787                               (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06788                             nextPC = 8 + MATCH_p; 
06789                             
06790                             #line 857 "machine/pentium/disassembler.m"
06791                             
06792 
06793                                     sprintf (str,  "IMUL.Ivd", DIS_REG32, DIS_EADDR32, DIS_I32);
06794 
06795                             
06796 
06797                             
06798                             
06799                             
06800                           }
06801                           
06802                         } /*opt-block*/
06803                         else { 
06804                           MATCH_w_32_24 = getDword(3 + MATCH_p); 
06805                           goto MATCH_label_a274; 
06806                           
06807                         } /*opt-block*/
06808                         
06809                         break;
06810                       case 2: 
06811                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06812                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06813                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06814                                 /* index at 16 */ && 
06815                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06816                           MATCH_w_32_56 = getDword(7 + MATCH_p); 
06817                           goto MATCH_label_a275; 
06818                           
06819                         } /*opt-block*/
06820                         else { 
06821                           MATCH_w_32_48 = getDword(6 + MATCH_p); 
06822                           goto MATCH_label_a276; 
06823                           
06824                         } /*opt-block*/
06825                         
06826                         break;
06827                       case 3: 
06828                         MATCH_w_32_16 = getDword(2 + MATCH_p); 
06829                         goto MATCH_label_a273; 
06830                         
06831                         break;
06832                       default: assert(0);
06833                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06834                   
06835                 } /*opt-block*/
06836                 else 
06837                   goto MATCH_label_a39;  /*opt-block+*/
06838                 break;
06839               case 2: 
06840                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
06841                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06842                   { 
06843                     int /* [~128..127] */ i8 = 
06844                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
06845                     nextPC = 2 + MATCH_p; 
06846                     
06847                     #line 531 "machine/pentium/disassembler.m"
06848                     
06849 
06850                             sprintf (str,  "PUSH.Ixob", DIS_I8);
06851 
06852                     
06853 
06854                     
06855                     
06856                     
06857                   }
06858                   
06859                 } /*opt-block*/
06860                 else 
06861                   goto MATCH_label_a39;  /*opt-block+*/
06862                 
06863                 break;
06864               case 3: 
06865                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
06866                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
06867                   
06868                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
06869                       case 0: 
06870                         
06871                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
06872                             case 0: case 1: case 2: case 3: case 6: case 7: 
06873                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06874                               goto MATCH_label_a277; 
06875                               
06876                               break;
06877                             case 4: 
06878                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
06879                               if ((MATCH_w_8_16 & 0x7) 
06880                                       /* base at 16 */ == 5 && 
06881                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06882                                       /* index at 16 */ && 
06883                                 (MATCH_w_8_16 >> 3 & 0x7) 
06884                                       /* index at 16 */ < 8)) { 
06885                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
06886                                 goto MATCH_label_a279; 
06887                                 
06888                               } /*opt-block*/
06889                               else { 
06890                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
06891                                 goto MATCH_label_a278; 
06892                                 
06893                               } /*opt-block*/
06894                               
06895                               break;
06896                             case 5: 
06897                               MATCH_w_8_48 = getByte(6 + MATCH_p); 
06898                               goto MATCH_label_a280; 
06899                               
06900                               break;
06901                             default: assert(0);
06902                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
06903                         break;
06904                       case 1: 
06905                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06906                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06907                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06908                                 /* index at 16 */ && 
06909                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06910                           MATCH_w_8_32 = getByte(4 + MATCH_p); 
06911                           { 
06912                             unsigned Eaddr = 1 + addressToPC(MATCH_p);
06913                             int /* [~128..127] */ i8 = 
06914                               sign_extend(
06915                                           (MATCH_w_8_32 & 0xff) 
06916                                                 /* i8 at 32 */, 8);
06917                             unsigned reg = 
06918                               (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
06919                             nextPC = 5 + MATCH_p; 
06920                             
06921                             #line 863 "machine/pentium/disassembler.m"
06922                             
06923 
06924                                     sprintf (str,  "IMUL.Ibod", DIS_REG32, DIS_EADDR32, DIS_I8);
06925 
06926                             
06927 
06928                             
06929                             
06930                             
06931                           }
06932                           
06933                         } /*opt-block*/
06934                         else { 
06935                           MATCH_w_8_24 = getByte(3 + MATCH_p); 
06936                           goto MATCH_label_a278; 
06937                           
06938                         } /*opt-block*/
06939                         
06940                         break;
06941                       case 2: 
06942                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06943                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
06944                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
06945                                 /* index at 16 */ && 
06946                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
06947                           MATCH_w_8_56 = getByte(7 + MATCH_p); 
06948                           goto MATCH_label_a279; 
06949                           
06950                         } /*opt-block*/
06951                         else { 
06952                           MATCH_w_8_48 = getByte(6 + MATCH_p); 
06953                           goto MATCH_label_a280; 
06954                           
06955                         } /*opt-block*/
06956                         
06957                         break;
06958                       case 3: 
06959                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
06960                         goto MATCH_label_a277; 
06961                         
06962                         break;
06963                       default: assert(0);
06964                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
06965                   
06966                 } /*opt-block*/
06967                 else 
06968                   goto MATCH_label_a39;  /*opt-block+*/
06969                 break;
06970               case 4: 
06971                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 0) { 
06972                   MATCH_name = MATCH_name_page_0[(MATCH_w_8_0 >> 3 & 0x1) 
06973                         /* page at 0 */]; 
06974                   { 
06975                     char *name = MATCH_name;
06976                     nextPC = 1 + MATCH_p; 
06977                     
06978                     #line 59 "machine/pentium/disassembler.m"
06979                        
06980 
06981                             sprintf (str, "%s", name);
06982 
06983                     
06984 
06985                     
06986                     
06987                     
06988                   }
06989                   
06990                 } /*opt-block*/
06991                 else 
06992                   goto MATCH_label_a39;  /*opt-block+*/
06993                 
06994                 break;
06995               case 5: 
06996                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 0) { 
06997                   MATCH_name = "SEG.GS"; 
06998                   { 
06999                     char *name = MATCH_name;
07000                     nextPC = 1 + MATCH_p; 
07001                     
07002                     #line 62 "machine/pentium/disassembler.m"
07003                     
07004 
07005                             sprintf (str, "%s", name);
07006 
07007                     
07008 
07009                     
07010                     
07011                     
07012                   }
07013                   
07014                 } /*opt-block*/
07015                 else 
07016                   goto MATCH_label_a39;  /*opt-block+*/
07017                 
07018                 break;
07019               case 6: 
07020                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) 
07021                   goto MATCH_label_a39;  /*opt-block+*/
07022                 else { 
07023                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
07024                   
07025                     switch((MATCH_w_8_8 >> 4 & 0xf) /* row at 8 */) {
07026                       case 0: 
07027                         
07028                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
07029                             case 0: case 2: case 4: case 6: 
07030                               goto MATCH_label_a39; break;
07031                             case 1: 
07032                               if ((MATCH_w_8_8 >> 3 & 0x1) 
07033                                       /* page at 8 */ == 1) { 
07034                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
07035                                 
07036                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
07037                                         /* mod at 16 */) {
07038                                     case 0: 
07039                                       
07040                                         switch((MATCH_w_8_16 & 0x7) 
07041                                               /* r_m at 16 */) {
07042                                           case 0: case 1: case 2: case 3: 
07043                                           case 6: case 7: 
07044                                             goto MATCH_label_a285; break;
07045                                           case 4: 
07046                                             MATCH_w_8_24 = 
07047                                               getByte(3 + MATCH_p); 
07048                                             if ((MATCH_w_8_24 & 0x7) 
07049                                                     /* base at 24 */ == 5 && 
07050                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
07051                                                     /* index at 24 */ && 
07052                                               (MATCH_w_8_24 >> 3 & 0x7) 
07053                                                     /* index at 24 */ < 8)) 
07054                                               goto MATCH_label_a287;  /*opt-block+*/
07055                                             else 
07056                                               goto MATCH_label_a286;  /*opt-block+*/
07057                                             
07058                                             break;
07059                                           case 5: 
07060                                             goto MATCH_label_a288; break;
07061                                           default: assert(0);
07062                                         } /* (MATCH_w_8_16 & 0x7) 
07063                                               -- r_m at 16 --*/ 
07064                                       break;
07065                                     case 1: 
07066                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
07067                                       if ((MATCH_w_8_16 & 0x7) 
07068                                               /* r_m at 16 */ == 4 && 
07069                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
07070                                               /* index at 24 */ && 
07071                                         (MATCH_w_8_24 >> 3 & 0x7) 
07072                                               /* index at 24 */ < 8)) { 
07073                                         unsigned Eaddr = 
07074                                           2 + addressToPC(MATCH_p);
07075                                         unsigned reg = 
07076                                           (MATCH_w_8_16 >> 3 & 0x7) 
07077                                                 /* reg_opcode at 16 */;
07078                                         nextPC = 5 + MATCH_p; 
07079                                         
07080                                         #line 1189 "machine/pentium/disassembler.m"
07081                                         
07082 
07083                                                 sprintf (str,  "ORmrow", DIS_EADDR16, DIS_REG16);
07084 
07085                                         
07086 
07087                                         
07088                                         
07089                                         
07090                                       } /*opt-block*//*opt-block+*/
07091                                       else 
07092                                         goto MATCH_label_a286;  /*opt-block+*/
07093                                       
07094                                       break;
07095                                     case 2: 
07096                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
07097                                       if ((MATCH_w_8_16 & 0x7) 
07098                                               /* r_m at 16 */ == 4 && 
07099                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
07100                                               /* index at 24 */ && 
07101                                         (MATCH_w_8_24 >> 3 & 0x7) 
07102                                               /* index at 24 */ < 8)) 
07103                                         goto MATCH_label_a287;  /*opt-block+*/
07104                                       else 
07105                                         goto MATCH_label_a288;  /*opt-block+*/
07106                                       
07107                                       break;
07108                                     case 3: 
07109                                       goto MATCH_label_a285; break;
07110                                     default: assert(0);
07111                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
07112                                         -- mod at 16 --*/ 
07113                                 
07114                               } /*opt-block*/
07115                               else { 
07116                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
07117                                 
07118                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
07119                                         /* mod at 16 */) {
07120                                     case 0: 
07121                                       
07122                                         switch((MATCH_w_8_16 & 0x7) 
07123                                               /* r_m at 16 */) {
07124                                           case 0: case 1: case 2: case 3: 
07125                                           case 6: case 7: 
07126                                             goto MATCH_label_a281; break;
07127                                           case 4: 
07128                                             MATCH_w_8_24 = 
07129                                               getByte(3 + MATCH_p); 
07130                                             if ((MATCH_w_8_24 & 0x7) 
07131                                                     /* base at 24 */ == 5 && 
07132                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
07133                                                     /* index at 24 */ && 
07134                                               (MATCH_w_8_24 >> 3 & 0x7) 
07135                                                     /* index at 24 */ < 8)) 
07136                                               goto MATCH_label_a283;  /*opt-block+*/
07137                                             else 
07138                                               goto MATCH_label_a282;  /*opt-block+*/
07139                                             
07140                                             break;
07141                                           case 5: 
07142                                             goto MATCH_label_a284; break;
07143                                           default: assert(0);
07144                                         } /* (MATCH_w_8_16 & 0x7) 
07145                                               -- r_m at 16 --*/ 
07146                                       break;
07147                                     case 1: 
07148                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
07149                                       if ((MATCH_w_8_16 & 0x7) 
07150                                               /* r_m at 16 */ == 4 && 
07151                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
07152                                               /* index at 24 */ && 
07153                                         (MATCH_w_8_24 >> 3 & 0x7) 
07154                                               /* index at 24 */ < 8)) { 
07155                                         unsigned Eaddr = 
07156                                           2 + addressToPC(MATCH_p);
07157                                         unsigned reg = 
07158                                           (MATCH_w_8_16 >> 3 & 0x7) 
07159                                                 /* reg_opcode at 16 */;
07160                                         nextPC = 5 + MATCH_p; 
07161                                         
07162                                         #line 1195 "machine/pentium/disassembler.m"
07163                                         
07164 
07165                                                 sprintf (str,  "ADDmrow", DIS_EADDR16, DIS_REG16);
07166 
07167                                         
07168 
07169                                         
07170                                         
07171                                         
07172                                       } /*opt-block*//*opt-block+*/
07173                                       else 
07174                                         goto MATCH_label_a282;  /*opt-block+*/
07175                                       
07176                                       break;
07177                                     case 2: 
07178                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
07179                                       if ((MATCH_w_8_16 & 0x7) 
07180                                               /* r_m at 16 */ == 4 && 
07181                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
07182                                               /* index at 24 */ && 
07183                                         (MATCH_w_8_24 >> 3 & 0x7) 
07184                                               /* index at 24 */ < 8)) 
07185                                         goto MATCH_label_a283;  /*opt-block+*/
07186                                       else 
07187                                         goto MATCH_label_a284;  /*opt-block+*/
07188                                       
07189                                       break;
07190                                     case 3: 
07191                                       goto MATCH_label_a281; break;
07192                                     default: assert(0);
07193                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
07194                                         -- mod at 16 --*/ 
07195                                 
07196                               } /*opt-block*/
07197                               break;
07198                             case 3: 
07199                               if ((MATCH_w_8_8 >> 3 & 0x1) 
07200                                       /* page at 8 */ == 1) { 
07201                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
07202                                 
07203                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
07204                                         /* mod at 16 */) {
07205                                     case 0: 
07206                                       
07207                                         switch((MATCH_w_8_16 & 0x7) 
07208                                               /* r_m at 16 */) {
07209                                           case 0: case 1: case 2: case 3: 
07210                                           case 6: case 7: 
07211                                             goto MATCH_label_a293; break;
07212                                           case 4: 
07213                                             MATCH_w_8_24 = 
07214                                               getByte(3 + MATCH_p); 
07215                                             if ((MATCH_w_8_24 & 0x7) 
07216                                                     /* base at 24 */ == 5 && 
07217                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
07218                                                     /* index at 24 */ && 
07219                                               (MATCH_w_8_24 >> 3 & 0x7) 
07220                                                     /* index at 24 */ < 8)) 
07221                                               goto MATCH_label_a295;  /*opt-block+*/
07222                                             else 
07223                                               goto MATCH_label_a294;  /*opt-block+*/
07224                                             
07225                                             break;
07226                                           case 5: 
07227                                             goto MATCH_label_a296; break;
07228                                           default: assert(0);
07229                                         } /* (MATCH_w_8_16 & 0x7) 
07230                                               -- r_m at 16 --*/ 
07231                                       break;
07232                                     case 1: 
07233                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
07234                                       if ((MATCH_w_8_16 & 0x7) 
07235                                               /* r_m at 16 */ == 4 && 
07236                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
07237                                               /* index at 24 */ && 
07238                                         (MATCH_w_8_24 >> 3 & 0x7) 
07239                                               /* index at 24 */ < 8)) { 
07240                                         unsigned Eaddr = 
07241                                           2 + addressToPC(MATCH_p);
07242                                         unsigned reg = 
07243                                           (MATCH_w_8_16 >> 3 & 0x7) 
07244                                                 /* reg_opcode at 16 */;
07245                                         nextPC = 5 + MATCH_p; 
07246                                         
07247                                         #line 1117 "machine/pentium/disassembler.m"
07248                                         
07249 
07250                                                 sprintf (str,  "ORrmow", DIS_REG16, DIS_EADDR16);
07251 
07252                                         
07253 
07254                                         
07255                                         
07256                                         
07257                                       } /*opt-block*//*opt-block+*/
07258                                       else 
07259                                         goto MATCH_label_a294;  /*opt-block+*/
07260                                       
07261                                       break;
07262                                     case 2: 
07263                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
07264                                       if ((MATCH_w_8_16 & 0x7) 
07265                                               /* r_m at 16 */ == 4 && 
07266                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
07267                                               /* index at 24 */ && 
07268                                         (MATCH_w_8_24 >> 3 & 0x7) 
07269                                               /* index at 24 */ < 8)) 
07270                                         goto MATCH_label_a295;  /*opt-block+*/
07271                                       else 
07272                                         goto MATCH_label_a296;  /*opt-block+*/
07273                                       
07274                                       break;
07275                                     case 3: 
07276                                       goto MATCH_label_a293; break;
07277                                     default: assert(0);
07278                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
07279                                         -- mod at 16 --*/ 
07280                                 
07281                               } /*opt-block*/
07282                               else { 
07283                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
07284                                 
07285                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
07286                                         /* mod at 16 */) {
07287                                     case 0: 
07288                                       
07289                                         switch((MATCH_w_8_16 & 0x7) 
07290                                               /* r_m at 16 */) {
07291                                           case 0: case 1: case 2: case 3: 
07292                                           case 6: case 7: 
07293                                             goto MATCH_label_a289; break;
07294                                           case 4: 
07295                                             MATCH_w_8_24 = 
07296                                               getByte(3 + MATCH_p); 
07297                                             if ((MATCH_w_8_24 & 0x7) 
07298                                                     /* base at 24 */ == 5 && 
07299                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
07300                                                     /* index at 24 */ && 
07301                                               (MATCH_w_8_24 >> 3 & 0x7) 
07302                                                     /* index at 24 */ < 8)) 
07303                                               goto MATCH_label_a291;  /*opt-block+*/
07304                                             else 
07305                                               goto MATCH_label_a290;  /*opt-block+*/
07306                                             
07307                                             break;
07308                                           case 5: 
07309                                             goto MATCH_label_a292; break;
07310                                           default: assert(0);
07311                                         } /* (MATCH_w_8_16 & 0x7) 
07312                                               -- r_m at 16 --*/ 
07313                                       break;
07314                                     case 1: 
07315                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
07316                                       if ((MATCH_w_8_16 & 0x7) 
07317                                               /* r_m at 16 */ == 4 && 
07318                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
07319                                               /* index at 24 */ && 
07320                                         (MATCH_w_8_24 >> 3 & 0x7) 
07321                                               /* index at 24 */ < 8)) { 
07322                                         unsigned Eaddr = 
07323                                           2 + addressToPC(MATCH_p);
07324                                         unsigned reg = 
07325                                           (MATCH_w_8_16 >> 3 & 0x7) 
07326                                                 /* reg_opcode at 16 */;
07327                                         nextPC = 5 + MATCH_p; 
07328                                         
07329                                         #line 1123 "machine/pentium/disassembler.m"
07330                                         
07331 
07332                                                 sprintf (str,  "ADDrmow", DIS_REG16, DIS_EADDR16);
07333 
07334                                         
07335 
07336                                         
07337                                         
07338                                         
07339                                       } /*opt-block*//*opt-block+*/
07340                                       else 
07341                                         goto MATCH_label_a290;  /*opt-block+*/
07342                                       
07343                                       break;
07344                                     case 2: 
07345                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
07346                                       if ((MATCH_w_8_16 & 0x7) 
07347                                               /* r_m at 16 */ == 4 && 
07348                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
07349                                               /* index at 24 */ && 
07350                                         (MATCH_w_8_24 >> 3 & 0x7) 
07351                                               /* index at 24 */ < 8)) 
07352                                         goto MATCH_label_a291;  /*opt-block+*/
07353                                       else 
07354                                         goto MATCH_label_a292;  /*opt-block+*/
07355                                       
07356                                       break;
07357                                     case 3: 
07358                                       goto MATCH_label_a289; break;
07359                                     default: assert(0);
07360                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
07361                                         -- mod at 16 --*/ 
07362                                 
07363                               } /*opt-block*/
07364                               break;
07365                             case 5: 
07366                               if ((MATCH_w_8_8 >> 3 & 0x1) 
07367                                       /* page at 8 */ == 1) { 
07368                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
07369                                 { 
07370                                   int /* [~32768..32767] */ i16 = 
07371                                     sign_extend(
07372                                                 (MATCH_w_16_16 & 0xffff) 
07373                                                       /* i16 at 16 */, 16);
07374                                   nextPC = 4 + MATCH_p; 
07375                                   
07376                                   #line 1384 "machine/pentium/disassembler.m"
07377                                   
07378 
07379                                           sprintf (str,  "ORiAX", DIS_I16);
07380 
07381                                   
07382 
07383                                   
07384                                   
07385                                   
07386                                 }
07387                                 
07388                               } /*opt-block*/
07389                               else { 
07390                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
07391                                 { 
07392                                   int /* [~32768..32767] */ i16 = 
07393                                     sign_extend(
07394                                                 (MATCH_w_16_16 & 0xffff) 
07395                                                       /* i16 at 16 */, 16);
07396                                   nextPC = 4 + MATCH_p; 
07397                                   
07398                                   #line 1387 "machine/pentium/disassembler.m"
07399                                   
07400 
07401                                           sprintf (str,  "ADDiAX", DIS_I16);
07402 
07403                                   
07404 
07405                                   
07406                                   
07407                                   
07408                                 }
07409                                 
07410                               } /*opt-block*/
07411                               
07412                               break;
07413                             case 7: 
07414                               if ((MATCH_w_8_8 >> 3 & 0x1) 
07415                                       /* page at 8 */ == 1) { 
07416                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
07417                                 
07418                                   switch((MATCH_w_8_16 >> 4 & 0xf) 
07419                                         /* row at 16 */) {
07420                                     case 0: 
07421                                       
07422                                         switch((MATCH_w_8_16 & 0x7) 
07423                                               /* col at 16 */) {
07424                                           case 0: case 1: case 4: case 5: 
07425                                           case 6: case 7: 
07426                                             goto MATCH_label_a39; break;
07427                                           case 2: 
07428                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
07429                                                     /* page at 16 */ == 1) 
07430                                               goto MATCH_label_a39;  /*opt-block+*/
07431                                             else { 
07432                                               MATCH_w_8_24 = 
07433                                                 getByte(3 + MATCH_p); 
07434                                               
07435                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
07436                                                       /* mod at 24 */) {
07437                                                   case 0: 
07438                                                     
07439                                                       switch((MATCH_w_8_24 & 0x7) 
07440                                                             /* r_m at 24 */) {
07441                                                         case 0: case 1: 
07442                                                         case 2: case 3: 
07443                                                         case 6: case 7: 
07444                                                           goto MATCH_label_a297; 
07445                                                           
07446                                                           break;
07447                                                         case 4: 
07448                                                           MATCH_w_8_32 = 
07449                                                             getByte(
07450                                                                   4 + 
07451                                                                   MATCH_p); 
07452                                                           if ((MATCH_w_8_32 & 0x7) 
07453                                                                   /* base at 32 */ == 5 && 
07454                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
07455                                                                   /* index at 32 */ && 
07456                                                             (MATCH_w_8_32 >> 3 & 0x7) 
07457                                                                   /* index at 32 */ < 8)) 
07458                                                             goto MATCH_label_a299;  /*opt-block+*/
07459                                                           else 
07460                                                             goto MATCH_label_a298;  /*opt-block+*/
07461                                                           
07462                                                           break;
07463                                                         case 5: 
07464                                                           goto MATCH_label_a300; 
07465                                                           
07466                                                           break;
07467                                                         default: assert(0);
07468                                                       } /* (MATCH_w_8_24 & 0x7) 
07469                                                             -- r_m at 24 --*/ 
07470                                                     break;
07471                                                   case 1: 
07472                                                     MATCH_w_8_32 = 
07473                                                       getByte(4 + MATCH_p); 
07474                                                     if ((MATCH_w_8_24 & 0x7) 
07475                                                             /* r_m at 24 */ == 4 && 
07476                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
07477                                                             /* index at 32 */ && 
07478                                                       (MATCH_w_8_32 >> 3 & 0x7) 
07479                                                             /* index at 32 */ < 8)) { 
07480                                                       unsigned Eaddr = 
07481                                                         3 + 
07482                                                         addressToPC(MATCH_p);
07483                                                       unsigned reg = 
07484                                                         (MATCH_w_8_24 >> 3 & 0x7) 
07485                                                               /* reg_opcode at 24 */;
07486                                                       nextPC = 6 + MATCH_p; 
07487                                                       
07488                                                       #line 790 "machine/pentium/disassembler.m"
07489                                                       
07490 
07491                                                               sprintf (str,  "LAR.ow", DIS_REG16, DIS_EADDR16);
07492 
07493                                                       
07494 
07495                                                       
07496                                                       
07497                                                       
07498                                                     } /*opt-block*//*opt-block+*/
07499                                                     else 
07500                                                       goto MATCH_label_a298;  /*opt-block+*/
07501                                                     
07502                                                     break;
07503                                                   case 2: 
07504                                                     MATCH_w_8_32 = 
07505                                                       getByte(4 + MATCH_p); 
07506                                                     if ((MATCH_w_8_24 & 0x7) 
07507                                                             /* r_m at 24 */ == 4 && 
07508                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
07509                                                             /* index at 32 */ && 
07510                                                       (MATCH_w_8_32 >> 3 & 0x7) 
07511                                                             /* index at 32 */ < 8)) 
07512                                                       goto MATCH_label_a299;  /*opt-block+*/
07513                                                     else 
07514                                                       goto MATCH_label_a300;  /*opt-block+*/
07515                                                     
07516                                                     break;
07517                                                   case 3: 
07518                                                     goto MATCH_label_a297; 
07519                                                     
07520                                                     break;
07521                                                   default: assert(0);
07522                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
07523                                                       -- mod at 24 --*/ 
07524                                               
07525                                             } /*opt-block*/
07526                                             break;
07527                                           case 3: 
07528                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
07529                                                     /* page at 16 */ == 1) 
07530                                               goto MATCH_label_a39;  /*opt-block+*/
07531                                             else { 
07532                                               MATCH_w_8_24 = 
07533                                                 getByte(3 + MATCH_p); 
07534                                               
07535                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
07536                                                       /* mod at 24 */) {
07537                                                   case 0: 
07538                                                     
07539                                                       switch((MATCH_w_8_24 & 0x7) 
07540                                                             /* r_m at 24 */) {
07541                                                         case 0: case 1: 
07542                                                         case 2: case 3: 
07543                                                         case 6: case 7: 
07544                                                           goto MATCH_label_a301; 
07545                                                           
07546                                                           break;
07547                                                         case 4: 
07548                                                           MATCH_w_8_32 = 
07549                                                             getByte(
07550                                                                   4 + 
07551                                                                   MATCH_p); 
07552                                                           if ((MATCH_w_8_32 & 0x7) 
07553                                                                   /* base at 32 */ == 5 && 
07554                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
07555                                                                   /* index at 32 */ && 
07556                                                             (MATCH_w_8_32 >> 3 & 0x7) 
07557                                                                   /* index at 32 */ < 8)) 
07558                                                             goto MATCH_label_a303;  /*opt-block+*/
07559                                                           else 
07560                                                             goto MATCH_label_a302;  /*opt-block+*/
07561                                                           
07562                                                           break;
07563                                                         case 5: 
07564                                                           goto MATCH_label_a304; 
07565                                                           
07566                                                           break;
07567                                                         default: assert(0);
07568                                                       } /* (MATCH_w_8_24 & 0x7) 
07569                                                             -- r_m at 24 --*/ 
07570                                                     break;
07571                                                   case 1: 
07572                                                     MATCH_w_8_32 = 
07573                                                       getByte(4 + MATCH_p); 
07574                                                     if ((MATCH_w_8_24 & 0x7) 
07575                                                             /* r_m at 24 */ == 4 && 
07576                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
07577                                                             /* index at 32 */ && 
07578                                                       (MATCH_w_8_32 >> 3 & 0x7) 
07579                                                             /* index at 32 */ < 8)) { 
07580                                                       unsigned Eaddr = 
07581                                                         3 + 
07582                                                         addressToPC(MATCH_p);
07583                                                       unsigned reg = 
07584                                                         (MATCH_w_8_24 >> 3 & 0x7) 
07585                                                               /* reg_opcode at 24 */;
07586                                                       nextPC = 6 + MATCH_p; 
07587                                                       
07588                                                       #line 754 "machine/pentium/disassembler.m"
07589                                                       
07590 
07591                                                               sprintf (str,  "LSLow", DIS_REG16, DIS_EADDR16);
07592 
07593                                                       
07594 
07595                                                       
07596                                                       
07597                                                       
07598                                                     } /*opt-block*//*opt-block+*/
07599                                                     else 
07600                                                       goto MATCH_label_a302;  /*opt-block+*/
07601                                                     
07602                                                     break;
07603                                                   case 2: 
07604                                                     MATCH_w_8_32 = 
07605                                                       getByte(4 + MATCH_p); 
07606                                                     if ((MATCH_w_8_24 & 0x7) 
07607                                                             /* r_m at 24 */ == 4 && 
07608                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
07609                                                             /* index at 32 */ && 
07610                                                       (MATCH_w_8_32 >> 3 & 0x7) 
07611                                                             /* index at 32 */ < 8)) 
07612                                                       goto MATCH_label_a303;  /*opt-block+*/
07613                                                     else 
07614                                                       goto MATCH_label_a304;  /*opt-block+*/
07615                                                     
07616                                                     break;
07617                                                   case 3: 
07618                                                     goto MATCH_label_a301; 
07619                                                     
07620                                                     break;
07621                                                   default: assert(0);
07622                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
07623                                                       -- mod at 24 --*/ 
07624                                               
07625                                             } /*opt-block*/
07626                                             break;
07627                                           default: assert(0);
07628                                         } /* (MATCH_w_8_16 & 0x7) 
07629                                               -- col at 16 --*/ 
07630                                       break;
07631                                     case 1: case 2: case 3: case 4: case 5: 
07632                                     case 6: case 7: case 8: case 9: case 13: 
07633                                     case 14: case 15: 
07634                                       goto MATCH_label_a39; break;
07635                                     case 10: 
07636                                       
07637                                         switch((MATCH_w_8_16 & 0x7) 
07638                                               /* col at 16 */) {
07639                                           case 0: case 1: case 2: case 6: 
07640                                             goto MATCH_label_a39; break;
07641                                           case 3: 
07642                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
07643                                                     /* page at 16 */ == 1) { 
07644                                               MATCH_w_8_24 = 
07645                                                 getByte(3 + MATCH_p); 
07646                                               
07647                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
07648                                                       /* mod at 24 */) {
07649                                                   case 0: 
07650                                                     
07651                                                       switch((MATCH_w_8_24 & 0x7) 
07652                                                             /* r_m at 24 */) {
07653                                                         case 0: case 1: 
07654                                                         case 2: case 3: 
07655                                                         case 6: case 7: 
07656                                                           goto MATCH_label_a309; 
07657                                                           
07658                                                           break;
07659                                                         case 4: 
07660                                                           MATCH_w_8_32 = 
07661                                                             getByte(
07662                                                                   4 + 
07663                                                                   MATCH_p); 
07664                                                           if ((MATCH_w_8_32 & 0x7) 
07665                                                                   /* base at 32 */ == 5 && 
07666                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
07667                                                                   /* index at 32 */ && 
07668                                                             (MATCH_w_8_32 >> 3 & 0x7) 
07669                                                                   /* index at 32 */ < 8)) 
07670                                                             goto MATCH_label_a311;  /*opt-block+*/
07671                                                           else 
07672                                                             goto MATCH_label_a310;  /*opt-block+*/
07673                                                           
07674                                                           break;
07675                                                         case 5: 
07676                                                           goto MATCH_label_a312; 
07677                                                           
07678                                                           break;
07679                                                         default: assert(0);
07680                                                       } /* (MATCH_w_8_24 & 0x7) 
07681                                                             -- r_m at 24 --*/ 
07682                                                     break;
07683                                                   case 1: 
07684                                                     MATCH_w_8_32 = 
07685                                                       getByte(4 + MATCH_p); 
07686                                                     if ((MATCH_w_8_24 & 0x7) 
07687                                                             /* r_m at 24 */ == 4 && 
07688                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
07689                                                             /* index at 32 */ && 
07690                                                       (MATCH_w_8_32 >> 3 & 0x7) 
07691                                                             /* index at 32 */ < 8)) { 
07692                                                       unsigned Eaddr = 
07693                                                         3 + 
07694                                                         addressToPC(MATCH_p);
07695                                                       unsigned reg = 
07696                                                         (MATCH_w_8_24 >> 3 & 0x7) 
07697                                                               /* reg_opcode at 24 */;
07698                                                       nextPC = 6 + MATCH_p; 
07699                                                       
07700                                                       #line 1001 "machine/pentium/disassembler.m"
07701                                                       
07702 
07703                                                               sprintf (str,  "BTSow", DIS_EADDR16, DIS_REG16);
07704 
07705                                                       
07706 
07707                                                       
07708                                                       
07709                                                       
07710                                                     } /*opt-block*//*opt-block+*/
07711                                                     else 
07712                                                       goto MATCH_label_a310;  /*opt-block+*/
07713                                                     
07714                                                     break;
07715                                                   case 2: 
07716                                                     MATCH_w_8_32 = 
07717                                                       getByte(4 + MATCH_p); 
07718                                                     if ((MATCH_w_8_24 & 0x7) 
07719                                                             /* r_m at 24 */ == 4 && 
07720                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
07721                                                             /* index at 32 */ && 
07722                                                       (MATCH_w_8_32 >> 3 & 0x7) 
07723                                                             /* index at 32 */ < 8)) 
07724                                                       goto MATCH_label_a311;  /*opt-block+*/
07725                                                     else 
07726                                                       goto MATCH_label_a312;  /*opt-block+*/
07727                                                     
07728                                                     break;
07729                                                   case 3: 
07730                                                     goto MATCH_label_a309; 
07731                                                     
07732                                                     break;
07733                                                   default: assert(0);
07734                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
07735                                                       -- mod at 24 --*/ 
07736                                               
07737                                             } /*opt-block*/
07738                                             else { 
07739                                               MATCH_w_8_24 = 
07740                                                 getByte(3 + MATCH_p); 
07741                                               
07742                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
07743                                                       /* mod at 24 */) {
07744                                                   case 0: 
07745                                                     
07746                                                       switch((MATCH_w_8_24 & 0x7) 
07747                                                             /* r_m at 24 */) {
07748                                                         case 0: case 1: 
07749                                                         case 2: case 3: 
07750                                                         case 6: case 7: 
07751                                                           goto MATCH_label_a305; 
07752                                                           
07753                                                           break;
07754                                                         case 4: 
07755                                                           MATCH_w_8_32 = 
07756                                                             getByte(
07757                                                                   4 + 
07758                                                                   MATCH_p); 
07759                                                           if ((MATCH_w_8_32 & 0x7) 
07760                                                                   /* base at 32 */ == 5 && 
07761                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
07762                                                                   /* index at 32 */ && 
07763                                                             (MATCH_w_8_32 >> 3 & 0x7) 
07764                                                                   /* index at 32 */ < 8)) 
07765                                                             goto MATCH_label_a307;  /*opt-block+*/
07766                                                           else 
07767                                                             goto MATCH_label_a306;  /*opt-block+*/
07768                                                           
07769                                                           break;
07770                                                         case 5: 
07771                                                           goto MATCH_label_a308; 
07772                                                           
07773                                                           break;
07774                                                         default: assert(0);
07775                                                       } /* (MATCH_w_8_24 & 0x7) 
07776                                                             -- r_m at 24 --*/ 
07777                                                     break;
07778                                                   case 1: 
07779                                                     MATCH_w_8_32 = 
07780                                                       getByte(4 + MATCH_p); 
07781                                                     if ((MATCH_w_8_24 & 0x7) 
07782                                                             /* r_m at 24 */ == 4 && 
07783                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
07784                                                             /* index at 32 */ && 
07785                                                       (MATCH_w_8_32 >> 3 & 0x7) 
07786                                                             /* index at 32 */ < 8)) { 
07787                                                       unsigned Eaddr = 
07788                                                         3 + 
07789                                                         addressToPC(MATCH_p);
07790                                                       unsigned reg = 
07791                                                         (MATCH_w_8_24 >> 3 & 0x7) 
07792                                                               /* reg_opcode at 24 */;
07793                                                       nextPC = 6 + MATCH_p; 
07794                                                       
07795                                                       #line 1037 "machine/pentium/disassembler.m"
07796                                                       
07797 
07798                                                               sprintf (str,  "BTow", DIS_EADDR16, DIS_REG16);
07799 
07800                                                       
07801 
07802                                                       
07803                                                       
07804                                                       
07805                                                     } /*opt-block*//*opt-block+*/
07806                                                     else 
07807                                                       goto MATCH_label_a306;  /*opt-block+*/
07808                                                     
07809                                                     break;
07810                                                   case 2: 
07811                                                     MATCH_w_8_32 = 
07812                                                       getByte(4 + MATCH_p); 
07813                                                     if ((MATCH_w_8_24 & 0x7) 
07814                                                             /* r_m at 24 */ == 4 && 
07815                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
07816                                                             /* index at 32 */ && 
07817                                                       (MATCH_w_8_32 >> 3 & 0x7) 
07818                                                             /* index at 32 */ < 8)) 
07819                                                       goto MATCH_label_a307;  /*opt-block+*/
07820                                                     else 
07821                                                       goto MATCH_label_a308;  /*opt-block+*/
07822                                                     
07823                                                     break;
07824                                                   case 3: 
07825                                                     goto MATCH_label_a305; 
07826                                                     
07827                                                     break;
07828                                                   default: assert(0);
07829                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
07830                                                       -- mod at 24 --*/ 
07831                                               
07832                                             } /*opt-block*/
07833                                             break;
07834                                           case 4: 
07835                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
07836                                                     /* page at 16 */ == 1) { 
07837                                               MATCH_w_8_24 = 
07838                                                 getByte(3 + MATCH_p); 
07839                                               
07840                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
07841                                                       /* mod at 24 */) {
07842                                                   case 0: 
07843                                                     
07844                                                       switch((MATCH_w_8_24 & 0x7) 
07845                                                             /* r_m at 24 */) {
07846                                                         case 0: case 1: 
07847                                                         case 2: case 3: 
07848                                                         case 6: case 7: 
07849                                                           MATCH_w_8_32 = 
07850                                                             getByte(
07851                                                                   4 + 
07852                                                                   MATCH_p); 
07853                                                           goto MATCH_label_a317; 
07854                                                           
07855                                                           break;
07856                                                         case 4: 
07857                                                           MATCH_w_8_32 = 
07858                                                             getByte(
07859                                                                   4 + 
07860                                                                   MATCH_p); 
07861                                                           if ((MATCH_w_8_32 & 0x7) 
07862                                                                   /* base at 32 */ == 5 && 
07863                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
07864                                                                   /* index at 32 */ && 
07865                                                             (MATCH_w_8_32 >> 3 & 0x7) 
07866                                                                   /* index at 32 */ < 8)) { 
07867                                                             MATCH_w_8_72 = 
07868                                                               getByte(
07869                                                                     9 + 
07870                                                                     MATCH_p); 
07871                                                             goto MATCH_label_a319; 
07872                                                             
07873                                                           } /*opt-block*/
07874                                                           else { 
07875                                                             MATCH_w_8_40 = 
07876                                                               getByte(
07877                                                                     5 + 
07878                                                                     MATCH_p); 
07879                                                             goto MATCH_label_a318; 
07880                                                             
07881                                                           } /*opt-block*/
07882                                                           
07883                                                           break;
07884                                                         case 5: 
07885                                                           MATCH_w_8_64 = 
07886                                                             getByte(
07887                                                                   8 + 
07888                                                                   MATCH_p); 
07889                                                           goto MATCH_label_a320; 
07890                                                           
07891                                                           break;
07892                                                         default: assert(0);
07893                                                       } /* (MATCH_w_8_24 & 0x7) 
07894                                                             -- r_m at 24 --*/ 
07895                                                     break;
07896                                                   case 1: 
07897                                                     MATCH_w_8_32 = 
07898                                                       getByte(4 + MATCH_p); 
07899                                                     if ((MATCH_w_8_24 & 0x7) 
07900                                                             /* r_m at 24 */ == 4 && 
07901                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
07902                                                             /* index at 32 */ && 
07903                                                       (MATCH_w_8_32 >> 3 & 0x7) 
07904                                                             /* index at 32 */ < 8)) { 
07905                                                       MATCH_w_8_48 = 
07906                                                         getByte(6 + MATCH_p); 
07907                                                       { 
07908                                                         unsigned Eaddr = 
07909                                                           3 + 
07910                                                           addressToPC(MATCH_p);
07911                                                         unsigned count = 
07912                                                           (MATCH_w_8_48 & 0xff) 
07913                                                                 /* i8 at 48 */;
07914                                                         unsigned reg = 
07915                                                           (MATCH_w_8_24 >> 3 & 0x7) 
07916                                                                 /* reg_opcode at 24 */;
07917                                                         nextPC = 7 + MATCH_p; 
07918                                                         
07919                                                         #line 170 "machine/pentium/disassembler.m"
07920                                                         
07921 
07922                                                                 sprintf (str,  "SHRD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
07923 
07924                                                         
07925 
07926                                                         
07927                                                         
07928                                                         
07929                                                       }
07930                                                       
07931                                                     } /*opt-block*/
07932                                                     else { 
07933                                                       MATCH_w_8_40 = 
07934                                                         getByte(5 + MATCH_p); 
07935                                                       goto MATCH_label_a318; 
07936                                                       
07937                                                     } /*opt-block*/
07938                                                     
07939                                                     break;
07940                                                   case 2: 
07941                                                     MATCH_w_8_32 = 
07942                                                       getByte(4 + MATCH_p); 
07943                                                     if ((MATCH_w_8_24 & 0x7) 
07944                                                             /* r_m at 24 */ == 4 && 
07945                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
07946                                                             /* index at 32 */ && 
07947                                                       (MATCH_w_8_32 >> 3 & 0x7) 
07948                                                             /* index at 32 */ < 8)) { 
07949                                                       MATCH_w_8_72 = 
07950                                                         getByte(9 + MATCH_p); 
07951                                                       goto MATCH_label_a319; 
07952                                                       
07953                                                     } /*opt-block*/
07954                                                     else { 
07955                                                       MATCH_w_8_64 = 
07956                                                         getByte(8 + MATCH_p); 
07957                                                       goto MATCH_label_a320; 
07958                                                       
07959                                                     } /*opt-block*/
07960                                                     
07961                                                     break;
07962                                                   case 3: 
07963                                                     MATCH_w_8_32 = 
07964                                                       getByte(4 + MATCH_p); 
07965                                                     goto MATCH_label_a317; 
07966                                                     
07967                                                     break;
07968                                                   default: assert(0);
07969                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
07970                                                       -- mod at 24 --*/ 
07971                                               
07972                                             } /*opt-block*/
07973                                             else { 
07974                                               MATCH_w_8_24 = 
07975                                                 getByte(3 + MATCH_p); 
07976                                               
07977                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
07978                                                       /* mod at 24 */) {
07979                                                   case 0: 
07980                                                     
07981                                                       switch((MATCH_w_8_24 & 0x7) 
07982                                                             /* r_m at 24 */) {
07983                                                         case 0: case 1: 
07984                                                         case 2: case 3: 
07985                                                         case 6: case 7: 
07986                                                           MATCH_w_8_32 = 
07987                                                             getByte(
07988                                                                   4 + 
07989                                                                   MATCH_p); 
07990                                                           goto MATCH_label_a313; 
07991                                                           
07992                                                           break;
07993                                                         case 4: 
07994                                                           MATCH_w_8_32 = 
07995                                                             getByte(
07996                                                                   4 + 
07997                                                                   MATCH_p); 
07998                                                           if ((MATCH_w_8_32 & 0x7) 
07999                                                                   /* base at 32 */ == 5 && 
08000                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08001                                                                   /* index at 32 */ && 
08002                                                             (MATCH_w_8_32 >> 3 & 0x7) 
08003                                                                   /* index at 32 */ < 8)) { 
08004                                                             MATCH_w_8_72 = 
08005                                                               getByte(
08006                                                                     9 + 
08007                                                                     MATCH_p); 
08008                                                             goto MATCH_label_a315; 
08009                                                             
08010                                                           } /*opt-block*/
08011                                                           else { 
08012                                                             MATCH_w_8_40 = 
08013                                                               getByte(
08014                                                                     5 + 
08015                                                                     MATCH_p); 
08016                                                             goto MATCH_label_a314; 
08017                                                             
08018                                                           } /*opt-block*/
08019                                                           
08020                                                           break;
08021                                                         case 5: 
08022                                                           MATCH_w_8_64 = 
08023                                                             getByte(
08024                                                                   8 + 
08025                                                                   MATCH_p); 
08026                                                           goto MATCH_label_a316; 
08027                                                           
08028                                                           break;
08029                                                         default: assert(0);
08030                                                       } /* (MATCH_w_8_24 & 0x7) 
08031                                                             -- r_m at 24 --*/ 
08032                                                     break;
08033                                                   case 1: 
08034                                                     MATCH_w_8_32 = 
08035                                                       getByte(4 + MATCH_p); 
08036                                                     if ((MATCH_w_8_24 & 0x7) 
08037                                                             /* r_m at 24 */ == 4 && 
08038                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08039                                                             /* index at 32 */ && 
08040                                                       (MATCH_w_8_32 >> 3 & 0x7) 
08041                                                             /* index at 32 */ < 8)) { 
08042                                                       MATCH_w_8_48 = 
08043                                                         getByte(6 + MATCH_p); 
08044                                                       { 
08045                                                         unsigned Eaddr = 
08046                                                           3 + 
08047                                                           addressToPC(MATCH_p);
08048                                                         unsigned count = 
08049                                                           (MATCH_w_8_48 & 0xff) 
08050                                                                 /* i8 at 48 */;
08051                                                         unsigned reg = 
08052                                                           (MATCH_w_8_24 >> 3 & 0x7) 
08053                                                                 /* reg_opcode at 24 */;
08054                                                         nextPC = 7 + MATCH_p; 
08055                                                         
08056                                                         #line 164 "machine/pentium/disassembler.m"
08057                                                         
08058 
08059                                                                 sprintf (str,  "SHLD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
08060 
08061                                                         
08062 
08063                                                         
08064                                                         
08065                                                         
08066                                                       }
08067                                                       
08068                                                     } /*opt-block*/
08069                                                     else { 
08070                                                       MATCH_w_8_40 = 
08071                                                         getByte(5 + MATCH_p); 
08072                                                       goto MATCH_label_a314; 
08073                                                       
08074                                                     } /*opt-block*/
08075                                                     
08076                                                     break;
08077                                                   case 2: 
08078                                                     MATCH_w_8_32 = 
08079                                                       getByte(4 + MATCH_p); 
08080                                                     if ((MATCH_w_8_24 & 0x7) 
08081                                                             /* r_m at 24 */ == 4 && 
08082                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08083                                                             /* index at 32 */ && 
08084                                                       (MATCH_w_8_32 >> 3 & 0x7) 
08085                                                             /* index at 32 */ < 8)) { 
08086                                                       MATCH_w_8_72 = 
08087                                                         getByte(9 + MATCH_p); 
08088                                                       goto MATCH_label_a315; 
08089                                                       
08090                                                     } /*opt-block*/
08091                                                     else { 
08092                                                       MATCH_w_8_64 = 
08093                                                         getByte(8 + MATCH_p); 
08094                                                       goto MATCH_label_a316; 
08095                                                       
08096                                                     } /*opt-block*/
08097                                                     
08098                                                     break;
08099                                                   case 3: 
08100                                                     MATCH_w_8_32 = 
08101                                                       getByte(4 + MATCH_p); 
08102                                                     goto MATCH_label_a313; 
08103                                                     
08104                                                     break;
08105                                                   default: assert(0);
08106                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
08107                                                       -- mod at 24 --*/ 
08108                                               
08109                                             } /*opt-block*/
08110                                             break;
08111                                           case 5: 
08112                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
08113                                                     /* page at 16 */ == 1) { 
08114                                               MATCH_w_8_24 = 
08115                                                 getByte(3 + MATCH_p); 
08116                                               
08117                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
08118                                                       /* mod at 24 */) {
08119                                                   case 0: 
08120                                                     
08121                                                       switch((MATCH_w_8_24 & 0x7) 
08122                                                             /* r_m at 24 */) {
08123                                                         case 0: case 1: 
08124                                                         case 2: case 3: 
08125                                                         case 6: case 7: 
08126                                                           goto MATCH_label_a325; 
08127                                                           
08128                                                           break;
08129                                                         case 4: 
08130                                                           MATCH_w_8_32 = 
08131                                                             getByte(
08132                                                                   4 + 
08133                                                                   MATCH_p); 
08134                                                           if ((MATCH_w_8_32 & 0x7) 
08135                                                                   /* base at 32 */ == 5 && 
08136                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08137                                                                   /* index at 32 */ && 
08138                                                             (MATCH_w_8_32 >> 3 & 0x7) 
08139                                                                   /* index at 32 */ < 8)) 
08140                                                             goto MATCH_label_a327;  /*opt-block+*/
08141                                                           else 
08142                                                             goto MATCH_label_a326;  /*opt-block+*/
08143                                                           
08144                                                           break;
08145                                                         case 5: 
08146                                                           goto MATCH_label_a328; 
08147                                                           
08148                                                           break;
08149                                                         default: assert(0);
08150                                                       } /* (MATCH_w_8_24 & 0x7) 
08151                                                             -- r_m at 24 --*/ 
08152                                                     break;
08153                                                   case 1: 
08154                                                     MATCH_w_8_32 = 
08155                                                       getByte(4 + MATCH_p); 
08156                                                     if ((MATCH_w_8_24 & 0x7) 
08157                                                             /* r_m at 24 */ == 4 && 
08158                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08159                                                             /* index at 32 */ && 
08160                                                       (MATCH_w_8_32 >> 3 & 0x7) 
08161                                                             /* index at 32 */ < 8)) { 
08162                                                       unsigned Eaddr = 
08163                                                         3 + 
08164                                                         addressToPC(MATCH_p);
08165                                                       unsigned reg = 
08166                                                         (MATCH_w_8_24 >> 3 & 0x7) 
08167                                                               /* reg_opcode at 24 */;
08168                                                       nextPC = 6 + MATCH_p; 
08169                                                       
08170                                                       #line 158 "machine/pentium/disassembler.m"
08171                                                       
08172 
08173                                                               sprintf (str,  "SHRD.CLow", DIS_EADDR16, DIS_REG16);
08174 
08175                                                       
08176 
08177                                                       
08178                                                       
08179                                                       
08180                                                     } /*opt-block*//*opt-block+*/
08181                                                     else 
08182                                                       goto MATCH_label_a326;  /*opt-block+*/
08183                                                     
08184                                                     break;
08185                                                   case 2: 
08186                                                     MATCH_w_8_32 = 
08187                                                       getByte(4 + MATCH_p); 
08188                                                     if ((MATCH_w_8_24 & 0x7) 
08189                                                             /* r_m at 24 */ == 4 && 
08190                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08191                                                             /* index at 32 */ && 
08192                                                       (MATCH_w_8_32 >> 3 & 0x7) 
08193                                                             /* index at 32 */ < 8)) 
08194                                                       goto MATCH_label_a327;  /*opt-block+*/
08195                                                     else 
08196                                                       goto MATCH_label_a328;  /*opt-block+*/
08197                                                     
08198                                                     break;
08199                                                   case 3: 
08200                                                     goto MATCH_label_a325; 
08201                                                     
08202                                                     break;
08203                                                   default: assert(0);
08204                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
08205                                                       -- mod at 24 --*/ 
08206                                               
08207                                             } /*opt-block*/
08208                                             else { 
08209                                               MATCH_w_8_24 = 
08210                                                 getByte(3 + MATCH_p); 
08211                                               
08212                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
08213                                                       /* mod at 24 */) {
08214                                                   case 0: 
08215                                                     
08216                                                       switch((MATCH_w_8_24 & 0x7) 
08217                                                             /* r_m at 24 */) {
08218                                                         case 0: case 1: 
08219                                                         case 2: case 3: 
08220                                                         case 6: case 7: 
08221                                                           goto MATCH_label_a321; 
08222                                                           
08223                                                           break;
08224                                                         case 4: 
08225                                                           MATCH_w_8_32 = 
08226                                                             getByte(
08227                                                                   4 + 
08228                                                                   MATCH_p); 
08229                                                           if ((MATCH_w_8_32 & 0x7) 
08230                                                                   /* base at 32 */ == 5 && 
08231                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08232                                                                   /* index at 32 */ && 
08233                                                             (MATCH_w_8_32 >> 3 & 0x7) 
08234                                                                   /* index at 32 */ < 8)) 
08235                                                             goto MATCH_label_a323;  /*opt-block+*/
08236                                                           else 
08237                                                             goto MATCH_label_a322;  /*opt-block+*/
08238                                                           
08239                                                           break;
08240                                                         case 5: 
08241                                                           goto MATCH_label_a324; 
08242                                                           
08243                                                           break;
08244                                                         default: assert(0);
08245                                                       } /* (MATCH_w_8_24 & 0x7) 
08246                                                             -- r_m at 24 --*/ 
08247                                                     break;
08248                                                   case 1: 
08249                                                     MATCH_w_8_32 = 
08250                                                       getByte(4 + MATCH_p); 
08251                                                     if ((MATCH_w_8_24 & 0x7) 
08252                                                             /* r_m at 24 */ == 4 && 
08253                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08254                                                             /* index at 32 */ && 
08255                                                       (MATCH_w_8_32 >> 3 & 0x7) 
08256                                                             /* index at 32 */ < 8)) { 
08257                                                       unsigned Eaddr = 
08258                                                         3 + 
08259                                                         addressToPC(MATCH_p);
08260                                                       unsigned reg = 
08261                                                         (MATCH_w_8_24 >> 3 & 0x7) 
08262                                                               /* reg_opcode at 24 */;
08263                                                       nextPC = 6 + MATCH_p; 
08264                                                       
08265                                                       #line 152 "machine/pentium/disassembler.m"
08266                                                       
08267 
08268                                                               sprintf (str,  "SHLD.CLow", DIS_EADDR16, DIS_REG16);
08269 
08270                                                       
08271 
08272                                                       
08273                                                       
08274                                                       
08275                                                     } /*opt-block*//*opt-block+*/
08276                                                     else 
08277                                                       goto MATCH_label_a322;  /*opt-block+*/
08278                                                     
08279                                                     break;
08280                                                   case 2: 
08281                                                     MATCH_w_8_32 = 
08282                                                       getByte(4 + MATCH_p); 
08283                                                     if ((MATCH_w_8_24 & 0x7) 
08284                                                             /* r_m at 24 */ == 4 && 
08285                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08286                                                             /* index at 32 */ && 
08287                                                       (MATCH_w_8_32 >> 3 & 0x7) 
08288                                                             /* index at 32 */ < 8)) 
08289                                                       goto MATCH_label_a323;  /*opt-block+*/
08290                                                     else 
08291                                                       goto MATCH_label_a324;  /*opt-block+*/
08292                                                     
08293                                                     break;
08294                                                   case 3: 
08295                                                     goto MATCH_label_a321; 
08296                                                     
08297                                                     break;
08298                                                   default: assert(0);
08299                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
08300                                                       -- mod at 24 --*/ 
08301                                               
08302                                             } /*opt-block*/
08303                                             break;
08304                                           case 7: 
08305                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
08306                                                     /* page at 16 */ == 1) { 
08307                                               MATCH_w_8_24 = 
08308                                                 getByte(3 + MATCH_p); 
08309                                               
08310                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
08311                                                       /* mod at 24 */) {
08312                                                   case 0: 
08313                                                     
08314                                                       switch((MATCH_w_8_24 & 0x7) 
08315                                                             /* r_m at 24 */) {
08316                                                         case 0: case 1: 
08317                                                         case 2: case 3: 
08318                                                         case 6: case 7: 
08319                                                           goto MATCH_label_a329; 
08320                                                           
08321                                                           break;
08322                                                         case 4: 
08323                                                           MATCH_w_8_32 = 
08324                                                             getByte(
08325                                                                   4 + 
08326                                                                   MATCH_p); 
08327                                                           if ((MATCH_w_8_32 & 0x7) 
08328                                                                   /* base at 32 */ == 5 && 
08329                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08330                                                                   /* index at 32 */ && 
08331                                                             (MATCH_w_8_32 >> 3 & 0x7) 
08332                                                                   /* index at 32 */ < 8)) 
08333                                                             goto MATCH_label_a331;  /*opt-block+*/
08334                                                           else 
08335                                                             goto MATCH_label_a330;  /*opt-block+*/
08336                                                           
08337                                                           break;
08338                                                         case 5: 
08339                                                           goto MATCH_label_a332; 
08340                                                           
08341                                                           break;
08342                                                         default: assert(0);
08343                                                       } /* (MATCH_w_8_24 & 0x7) 
08344                                                             -- r_m at 24 --*/ 
08345                                                     break;
08346                                                   case 1: 
08347                                                     MATCH_w_8_32 = 
08348                                                       getByte(4 + MATCH_p); 
08349                                                     if ((MATCH_w_8_24 & 0x7) 
08350                                                             /* r_m at 24 */ == 4 && 
08351                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08352                                                             /* index at 32 */ && 
08353                                                       (MATCH_w_8_32 >> 3 & 0x7) 
08354                                                             /* index at 32 */ < 8)) { 
08355                                                       unsigned Eaddr = 
08356                                                         3 + 
08357                                                         addressToPC(MATCH_p);
08358                                                       unsigned reg = 
08359                                                         (MATCH_w_8_24 >> 3 & 0x7) 
08360                                                               /* reg_opcode at 24 */;
08361                                                       nextPC = 6 + MATCH_p; 
08362                                                       
08363                                                       #line 872 "machine/pentium/disassembler.m"
08364                                                       
08365 
08366                                                               sprintf (str,  "IMULrmow", DIS_REG16, DIS_EADDR16);
08367 
08368                                                       
08369 
08370                                                       
08371                                                       
08372                                                       
08373                                                     } /*opt-block*//*opt-block+*/
08374                                                     else 
08375                                                       goto MATCH_label_a330;  /*opt-block+*/
08376                                                     
08377                                                     break;
08378                                                   case 2: 
08379                                                     MATCH_w_8_32 = 
08380                                                       getByte(4 + MATCH_p); 
08381                                                     if ((MATCH_w_8_24 & 0x7) 
08382                                                             /* r_m at 24 */ == 4 && 
08383                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08384                                                             /* index at 32 */ && 
08385                                                       (MATCH_w_8_32 >> 3 & 0x7) 
08386                                                             /* index at 32 */ < 8)) 
08387                                                       goto MATCH_label_a331;  /*opt-block+*/
08388                                                     else 
08389                                                       goto MATCH_label_a332;  /*opt-block+*/
08390                                                     
08391                                                     break;
08392                                                   case 3: 
08393                                                     goto MATCH_label_a329; 
08394                                                     
08395                                                     break;
08396                                                   default: assert(0);
08397                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
08398                                                       -- mod at 24 --*/ 
08399                                               
08400                                             } /*opt-block*/
08401                                             else 
08402                                               goto MATCH_label_a39;  /*opt-block+*/
08403                                             break;
08404                                           default: assert(0);
08405                                         } /* (MATCH_w_8_16 & 0x7) 
08406                                               -- col at 16 --*/ 
08407                                       break;
08408                                     case 11: 
08409                                       
08410                                         switch((MATCH_w_8_16 & 0x7) 
08411                                               /* col at 16 */) {
08412                                           case 0: case 7: 
08413                                             goto MATCH_label_a39; break;
08414                                           case 1: 
08415                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
08416                                                     /* page at 16 */ == 1) 
08417                                               goto MATCH_label_a39;  /*opt-block+*/
08418                                             else { 
08419                                               MATCH_w_8_24 = 
08420                                                 getByte(3 + MATCH_p); 
08421                                               
08422                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
08423                                                       /* mod at 24 */) {
08424                                                   case 0: 
08425                                                     
08426                                                       switch((MATCH_w_8_24 & 0x7) 
08427                                                             /* r_m at 24 */) {
08428                                                         case 0: case 1: 
08429                                                         case 2: case 3: 
08430                                                         case 6: case 7: 
08431                                                           goto MATCH_label_a333; 
08432                                                           
08433                                                           break;
08434                                                         case 4: 
08435                                                           MATCH_w_8_32 = 
08436                                                             getByte(
08437                                                                   4 + 
08438                                                                   MATCH_p); 
08439                                                           if ((MATCH_w_8_32 & 0x7) 
08440                                                                   /* base at 32 */ == 5 && 
08441                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08442                                                                   /* index at 32 */ && 
08443                                                             (MATCH_w_8_32 >> 3 & 0x7) 
08444                                                                   /* index at 32 */ < 8)) 
08445                                                             goto MATCH_label_a335;  /*opt-block+*/
08446                                                           else 
08447                                                             goto MATCH_label_a334;  /*opt-block+*/
08448                                                           
08449                                                           break;
08450                                                         case 5: 
08451                                                           goto MATCH_label_a336; 
08452                                                           
08453                                                           break;
08454                                                         default: assert(0);
08455                                                       } /* (MATCH_w_8_24 & 0x7) 
08456                                                             -- r_m at 24 --*/ 
08457                                                     break;
08458                                                   case 1: 
08459                                                     MATCH_w_8_32 = 
08460                                                       getByte(4 + MATCH_p); 
08461                                                     if ((MATCH_w_8_24 & 0x7) 
08462                                                             /* r_m at 24 */ == 4 && 
08463                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08464                                                             /* index at 32 */ && 
08465                                                       (MATCH_w_8_32 >> 3 & 0x7) 
08466                                                             /* index at 32 */ < 8)) { 
08467                                                       unsigned Eaddr = 
08468                                                         3 + 
08469                                                         addressToPC(MATCH_p);
08470                                                       unsigned reg = 
08471                                                         (MATCH_w_8_24 >> 3 & 0x7) 
08472                                                               /* reg_opcode at 24 */;
08473                                                       nextPC = 6 + MATCH_p; 
08474                                                       
08475                                                       #line 944 "machine/pentium/disassembler.m"
08476                                                       
08477 
08478                                                               sprintf (str,  "CMPXCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
08479 
08480                                                       
08481 
08482                                                       
08483                                                       
08484                                                       
08485                                                     } /*opt-block*//*opt-block+*/
08486                                                     else 
08487                                                       goto MATCH_label_a334;  /*opt-block+*/
08488                                                     
08489                                                     break;
08490                                                   case 2: 
08491                                                     MATCH_w_8_32 = 
08492                                                       getByte(4 + MATCH_p); 
08493                                                     if ((MATCH_w_8_24 & 0x7) 
08494                                                             /* r_m at 24 */ == 4 && 
08495                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08496                                                             /* index at 32 */ && 
08497                                                       (MATCH_w_8_32 >> 3 & 0x7) 
08498                                                             /* index at 32 */ < 8)) 
08499                                                       goto MATCH_label_a335;  /*opt-block+*/
08500                                                     else 
08501                                                       goto MATCH_label_a336;  /*opt-block+*/
08502                                                     
08503                                                     break;
08504                                                   case 3: 
08505                                                     goto MATCH_label_a333; 
08506                                                     
08507                                                     break;
08508                                                   default: assert(0);
08509                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
08510                                                       -- mod at 24 --*/ 
08511                                               
08512                                             } /*opt-block*/
08513                                             break;
08514                                           case 2: 
08515                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
08516                                                     /* page at 16 */ == 1) { 
08517                                               MATCH_w_8_24 = 
08518                                                 getByte(3 + MATCH_p); 
08519                                               
08520                                                 switch((MATCH_w_8_24 >> 3 & 0x7) 
08521                                                       /* reg_opcode at 24 */) {
08522                                                   case 0: case 1: case 2: 
08523                                                   case 3: 
08524                                                     goto MATCH_label_a39; 
08525                                                     
08526                                                     break;
08527                                                   case 4: 
08528                                                     
08529                                                       switch((MATCH_w_8_24 >> 6 & 0x3) 
08530                                                             /* mod at 24 */) {
08531                                                         case 0: 
08532                                                           
08533                                                             switch((MATCH_w_8_24 & 0x7) 
08534                                                                   /* r_m at 24 */) {
08535                                                               case 0: case 1: 
08536                                                               case 2: case 3: 
08537                                                               case 6: case 7: 
08538                                                                 MATCH_w_8_32 = 
08539                                                                   getByte(
08540                                                                         4 + 
08541                                                                         MATCH_p); 
08542                                                                 goto MATCH_label_a337; 
08543                                                                 
08544                                                                 break;
08545                                                               case 4: 
08546                                                                 MATCH_w_8_32 = 
08547                                                                   getByte(
08548                                                                         4 + 
08549                                                                         MATCH_p); 
08550                                                                 if ((MATCH_w_8_32 & 0x7) 
08551                                                                         /* base at 32 */ == 5 && 
08552                                                                   (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08553                                                                         /* index at 32 */ && 
08554                                                                   (MATCH_w_8_32 >> 3 & 0x7) 
08555                                                                         /* index at 32 */ < 8)) { 
08556                                                                   MATCH_w_8_72 = 
08557                                                                     getByte(
08558                                                                           9 + 
08559                                                                           MATCH_p); 
08560                                                                   goto MATCH_label_a339; 
08561                                                                   
08562                                                                 } /*opt-block*/
08563                                                                 else { 
08564                                                                   MATCH_w_8_40 = 
08565                                                                     getByte(
08566                                                                           5 + 
08567                                                                           MATCH_p); 
08568                                                                   goto MATCH_label_a338; 
08569                                                                   
08570                                                                 } /*opt-block*/
08571                                                                 
08572                                                                 break;
08573                                                               case 5: 
08574                                                                 MATCH_w_8_64 = 
08575                                                                   getByte(
08576                                                                         8 + 
08577                                                                         MATCH_p); 
08578                                                                 goto MATCH_label_a340; 
08579                                                                 
08580                                                                 break;
08581                                                               default: assert(0);
08582                                                             } /* (MATCH_w_8_24 & 0x7) 
08583                                                                   -- r_m at 24 --*/ 
08584                                                           break;
08585                                                         case 1: 
08586                                                           MATCH_w_8_32 = 
08587                                                             getByte(
08588                                                                   4 + 
08589                                                                   MATCH_p); 
08590                                                           if ((MATCH_w_8_24 & 0x7) 
08591                                                                   /* r_m at 24 */ == 4 && 
08592                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08593                                                                   /* index at 32 */ && 
08594                                                             (MATCH_w_8_32 >> 3 & 0x7) 
08595                                                                   /* index at 32 */ < 8)) { 
08596                                                             MATCH_w_8_48 = 
08597                                                               getByte(
08598                                                                     6 + 
08599                                                                     MATCH_p); 
08600                                                             { 
08601                                                               unsigned Eaddr = 
08602                                                                 3 + 
08603                                                                 addressToPC(
08604                                                                             MATCH_p);
08605                                                               int /* [~128..127] */ i8 = 
08606                                                                 sign_extend(
08607                                                                             (MATCH_w_8_48 & 0xff) 
08608                                                                                   /* i8 at 48 */, 
08609                                                                             8);
08610                                                               nextPC = 7 + 
08611                                                               MATCH_p; 
08612                                                               
08613                                                               #line 1031 "machine/pentium/disassembler.m"
08614                                                               
08615 
08616                                                                       sprintf (str,  "BTiow", DIS_EADDR16, DIS_I8);
08617 
08618                                                               
08619 
08620                                                               
08621                                                               
08622                                                               
08623                                                             }
08624                                                             
08625                                                           } /*opt-block*/
08626                                                           else { 
08627                                                             MATCH_w_8_40 = 
08628                                                               getByte(
08629                                                                     5 + 
08630                                                                     MATCH_p); 
08631                                                             goto MATCH_label_a338; 
08632                                                             
08633                                                           } /*opt-block*/
08634                                                           
08635                                                           break;
08636                                                         case 2: 
08637                                                           MATCH_w_8_32 = 
08638                                                             getByte(
08639                                                                   4 + 
08640                                                                   MATCH_p); 
08641                                                           if ((MATCH_w_8_24 & 0x7) 
08642                                                                   /* r_m at 24 */ == 4 && 
08643                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08644                                                                   /* index at 32 */ && 
08645                                                             (MATCH_w_8_32 >> 3 & 0x7) 
08646                                                                   /* index at 32 */ < 8)) { 
08647                                                             MATCH_w_8_72 = 
08648                                                               getByte(
08649                                                                     9 + 
08650                                                                     MATCH_p); 
08651                                                             goto MATCH_label_a339; 
08652                                                             
08653                                                           } /*opt-block*/
08654                                                           else { 
08655                                                             MATCH_w_8_64 = 
08656                                                               getByte(
08657                                                                     8 + 
08658                                                                     MATCH_p); 
08659                                                             goto MATCH_label_a340; 
08660                                                             
08661                                                           } /*opt-block*/
08662                                                           
08663                                                           break;
08664                                                         case 3: 
08665                                                           MATCH_w_8_32 = 
08666                                                             getByte(
08667                                                                   4 + 
08668                                                                   MATCH_p); 
08669                                                           goto MATCH_label_a337; 
08670                                                           
08671                                                           break;
08672                                                         default: assert(0);
08673                                                       } /* (MATCH_w_8_24 >> 6 & 0x3) 
08674                                                             -- mod at 24 --*/ 
08675                                                     break;
08676                                                   case 5: 
08677                                                     
08678                                                       switch((MATCH_w_8_24 >> 6 & 0x3) 
08679                                                             /* mod at 24 */) {
08680                                                         case 0: 
08681                                                           
08682                                                             switch((MATCH_w_8_24 & 0x7) 
08683                                                                   /* r_m at 24 */) {
08684                                                               case 0: case 1: 
08685                                                               case 2: case 3: 
08686                                                               case 6: case 7: 
08687                                                                 MATCH_w_8_32 = 
08688                                                                   getByte(
08689                                                                         4 + 
08690                                                                         MATCH_p); 
08691                                                                 goto MATCH_label_a341; 
08692                                                                 
08693                                                                 break;
08694                                                               case 4: 
08695                                                                 MATCH_w_8_32 = 
08696                                                                   getByte(
08697                                                                         4 + 
08698                                                                         MATCH_p); 
08699                                                                 if ((MATCH_w_8_32 & 0x7) 
08700                                                                         /* base at 32 */ == 5 && 
08701                                                                   (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08702                                                                         /* index at 32 */ && 
08703                                                                   (MATCH_w_8_32 >> 3 & 0x7) 
08704                                                                         /* index at 32 */ < 8)) { 
08705                                                                   MATCH_w_8_72 = 
08706                                                                     getByte(
08707                                                                           9 + 
08708                                                                           MATCH_p); 
08709                                                                   goto MATCH_label_a343; 
08710                                                                   
08711                                                                 } /*opt-block*/
08712                                                                 else { 
08713                                                                   MATCH_w_8_40 = 
08714                                                                     getByte(
08715                                                                           5 + 
08716                                                                           MATCH_p); 
08717                                                                   goto MATCH_label_a342; 
08718                                                                   
08719                                                                 } /*opt-block*/
08720                                                                 
08721                                                                 break;
08722                                                               case 5: 
08723                                                                 MATCH_w_8_64 = 
08724                                                                   getByte(
08725                                                                         8 + 
08726                                                                         MATCH_p); 
08727                                                                 goto MATCH_label_a344; 
08728                                                                 
08729                                                                 break;
08730                                                               default: assert(0);
08731                                                             } /* (MATCH_w_8_24 & 0x7) 
08732                                                                   -- r_m at 24 --*/ 
08733                                                           break;
08734                                                         case 1: 
08735                                                           MATCH_w_8_32 = 
08736                                                             getByte(
08737                                                                   4 + 
08738                                                                   MATCH_p); 
08739                                                           if ((MATCH_w_8_24 & 0x7) 
08740                                                                   /* r_m at 24 */ == 4 && 
08741                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08742                                                                   /* index at 32 */ && 
08743                                                             (MATCH_w_8_32 >> 3 & 0x7) 
08744                                                                   /* index at 32 */ < 8)) { 
08745                                                             MATCH_w_8_48 = 
08746                                                               getByte(
08747                                                                     6 + 
08748                                                                     MATCH_p); 
08749                                                             { 
08750                                                               unsigned Eaddr = 
08751                                                                 3 + 
08752                                                                 addressToPC(
08753                                                                             MATCH_p);
08754                                                               int /* [~128..127] */ i8 = 
08755                                                                 sign_extend(
08756                                                                             (MATCH_w_8_48 & 0xff) 
08757                                                                                   /* i8 at 48 */, 
08758                                                                             8);
08759                                                               nextPC = 7 + 
08760                                                               MATCH_p; 
08761                                                               
08762                                                               #line 995 "machine/pentium/disassembler.m"
08763                                                               
08764 
08765                                                                       sprintf (str,  "BTSiow", DIS_I8, DIS_EADDR16);
08766 
08767                                                               
08768 
08769                                                               
08770                                                               
08771                                                               
08772                                                             }
08773                                                             
08774                                                           } /*opt-block*/
08775                                                           else { 
08776                                                             MATCH_w_8_40 = 
08777                                                               getByte(
08778                                                                     5 + 
08779                                                                     MATCH_p); 
08780                                                             goto MATCH_label_a342; 
08781                                                             
08782                                                           } /*opt-block*/
08783                                                           
08784                                                           break;
08785                                                         case 2: 
08786                                                           MATCH_w_8_32 = 
08787                                                             getByte(
08788                                                                   4 + 
08789                                                                   MATCH_p); 
08790                                                           if ((MATCH_w_8_24 & 0x7) 
08791                                                                   /* r_m at 24 */ == 4 && 
08792                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08793                                                                   /* index at 32 */ && 
08794                                                             (MATCH_w_8_32 >> 3 & 0x7) 
08795                                                                   /* index at 32 */ < 8)) { 
08796                                                             MATCH_w_8_72 = 
08797                                                               getByte(
08798                                                                     9 + 
08799                                                                     MATCH_p); 
08800                                                             goto MATCH_label_a343; 
08801                                                             
08802                                                           } /*opt-block*/
08803                                                           else { 
08804                                                             MATCH_w_8_64 = 
08805                                                               getByte(
08806                                                                     8 + 
08807                                                                     MATCH_p); 
08808                                                             goto MATCH_label_a344; 
08809                                                             
08810                                                           } /*opt-block*/
08811                                                           
08812                                                           break;
08813                                                         case 3: 
08814                                                           MATCH_w_8_32 = 
08815                                                             getByte(
08816                                                                   4 + 
08817                                                                   MATCH_p); 
08818                                                           goto MATCH_label_a341; 
08819                                                           
08820                                                           break;
08821                                                         default: assert(0);
08822                                                       } /* (MATCH_w_8_24 >> 6 & 0x3) 
08823                                                             -- mod at 24 --*/ 
08824                                                     break;
08825                                                   case 6: 
08826                                                     
08827                                                       switch((MATCH_w_8_24 >> 6 & 0x3) 
08828                                                             /* mod at 24 */) {
08829                                                         case 0: 
08830                                                           
08831                                                             switch((MATCH_w_8_24 & 0x7) 
08832                                                                   /* r_m at 24 */) {
08833                                                               case 0: case 1: 
08834                                                               case 2: case 3: 
08835                                                               case 6: case 7: 
08836                                                                 MATCH_w_8_32 = 
08837                                                                   getByte(
08838                                                                         4 + 
08839                                                                         MATCH_p); 
08840                                                                 goto MATCH_label_a345; 
08841                                                                 
08842                                                                 break;
08843                                                               case 4: 
08844                                                                 MATCH_w_8_32 = 
08845                                                                   getByte(
08846                                                                         4 + 
08847                                                                         MATCH_p); 
08848                                                                 if ((MATCH_w_8_32 & 0x7) 
08849                                                                         /* base at 32 */ == 5 && 
08850                                                                   (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08851                                                                         /* index at 32 */ && 
08852                                                                   (MATCH_w_8_32 >> 3 & 0x7) 
08853                                                                         /* index at 32 */ < 8)) { 
08854                                                                   MATCH_w_8_72 = 
08855                                                                     getByte(
08856                                                                           9 + 
08857                                                                           MATCH_p); 
08858                                                                   goto MATCH_label_a347; 
08859                                                                   
08860                                                                 } /*opt-block*/
08861                                                                 else { 
08862                                                                   MATCH_w_8_40 = 
08863                                                                     getByte(
08864                                                                           5 + 
08865                                                                           MATCH_p); 
08866                                                                   goto MATCH_label_a346; 
08867                                                                   
08868                                                                 } /*opt-block*/
08869                                                                 
08870                                                                 break;
08871                                                               case 5: 
08872                                                                 MATCH_w_8_64 = 
08873                                                                   getByte(
08874                                                                         8 + 
08875                                                                         MATCH_p); 
08876                                                                 goto MATCH_label_a348; 
08877                                                                 
08878                                                                 break;
08879                                                               default: assert(0);
08880                                                             } /* (MATCH_w_8_24 & 0x7) 
08881                                                                   -- r_m at 24 --*/ 
08882                                                           break;
08883                                                         case 1: 
08884                                                           MATCH_w_8_32 = 
08885                                                             getByte(
08886                                                                   4 + 
08887                                                                   MATCH_p); 
08888                                                           if ((MATCH_w_8_24 & 0x7) 
08889                                                                   /* r_m at 24 */ == 4 && 
08890                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08891                                                                   /* index at 32 */ && 
08892                                                             (MATCH_w_8_32 >> 3 & 0x7) 
08893                                                                   /* index at 32 */ < 8)) { 
08894                                                             MATCH_w_8_48 = 
08895                                                               getByte(
08896                                                                     6 + 
08897                                                                     MATCH_p); 
08898                                                             { 
08899                                                               unsigned Eaddr = 
08900                                                                 3 + 
08901                                                                 addressToPC(
08902                                                                             MATCH_p);
08903                                                               int /* [~128..127] */ i8 = 
08904                                                                 sign_extend(
08905                                                                             (MATCH_w_8_48 & 0xff) 
08906                                                                                   /* i8 at 48 */, 
08907                                                                             8);
08908                                                               nextPC = 7 + 
08909                                                               MATCH_p; 
08910                                                               
08911                                                               #line 1007 "machine/pentium/disassembler.m"
08912                                                               
08913 
08914                                                                       sprintf (str,  "BTRiow", DIS_EADDR16, DIS_I8);
08915 
08916                                                               
08917 
08918                                                               
08919                                                               
08920                                                               
08921                                                             }
08922                                                             
08923                                                           } /*opt-block*/
08924                                                           else { 
08925                                                             MATCH_w_8_40 = 
08926                                                               getByte(
08927                                                                     5 + 
08928                                                                     MATCH_p); 
08929                                                             goto MATCH_label_a346; 
08930                                                             
08931                                                           } /*opt-block*/
08932                                                           
08933                                                           break;
08934                                                         case 2: 
08935                                                           MATCH_w_8_32 = 
08936                                                             getByte(
08937                                                                   4 + 
08938                                                                   MATCH_p); 
08939                                                           if ((MATCH_w_8_24 & 0x7) 
08940                                                                   /* r_m at 24 */ == 4 && 
08941                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
08942                                                                   /* index at 32 */ && 
08943                                                             (MATCH_w_8_32 >> 3 & 0x7) 
08944                                                                   /* index at 32 */ < 8)) { 
08945                                                             MATCH_w_8_72 = 
08946                                                               getByte(
08947                                                                     9 + 
08948                                                                     MATCH_p); 
08949                                                             goto MATCH_label_a347; 
08950                                                             
08951                                                           } /*opt-block*/
08952                                                           else { 
08953                                                             MATCH_w_8_64 = 
08954                                                               getByte(
08955                                                                     8 + 
08956                                                                     MATCH_p); 
08957                                                             goto MATCH_label_a348; 
08958                                                             
08959                                                           } /*opt-block*/
08960                                                           
08961                                                           break;
08962                                                         case 3: 
08963                                                           MATCH_w_8_32 = 
08964                                                             getByte(
08965                                                                   4 + 
08966                                                                   MATCH_p); 
08967                                                           goto MATCH_label_a345; 
08968                                                           
08969                                                           break;
08970                                                         default: assert(0);
08971                                                       } /* (MATCH_w_8_24 >> 6 & 0x3) 
08972                                                             -- mod at 24 --*/ 
08973                                                     break;
08974                                                   case 7: 
08975                                                     
08976                                                       switch((MATCH_w_8_24 >> 6 & 0x3) 
08977                                                             /* mod at 24 */) {
08978                                                         case 0: 
08979                                                           
08980                                                             switch((MATCH_w_8_24 & 0x7) 
08981                                                                   /* r_m at 24 */) {
08982                                                               case 0: case 1: 
08983                                                               case 2: case 3: 
08984                                                               case 6: case 7: 
08985                                                                 MATCH_w_8_32 = 
08986                                                                   getByte(
08987                                                                         4 + 
08988                                                                         MATCH_p); 
08989                                                                 goto MATCH_label_a349; 
08990                                                                 
08991                                                                 break;
08992                                                               case 4: 
08993                                                                 MATCH_w_8_32 = 
08994                                                                   getByte(
08995                                                                         4 + 
08996                                                                         MATCH_p); 
08997                                                                 if ((MATCH_w_8_32 & 0x7) 
08998                                                                         /* base at 32 */ == 5 && 
08999                                                                   (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09000                                                                         /* index at 32 */ && 
09001                                                                   (MATCH_w_8_32 >> 3 & 0x7) 
09002                                                                         /* index at 32 */ < 8)) { 
09003                                                                   MATCH_w_8_72 = 
09004                                                                     getByte(
09005                                                                           9 + 
09006                                                                           MATCH_p); 
09007                                                                   goto MATCH_label_a351; 
09008                                                                   
09009                                                                 } /*opt-block*/
09010                                                                 else { 
09011                                                                   MATCH_w_8_40 = 
09012                                                                     getByte(
09013                                                                           5 + 
09014                                                                           MATCH_p); 
09015                                                                   goto MATCH_label_a350; 
09016                                                                   
09017                                                                 } /*opt-block*/
09018                                                                 
09019                                                                 break;
09020                                                               case 5: 
09021                                                                 MATCH_w_8_64 = 
09022                                                                   getByte(
09023                                                                         8 + 
09024                                                                         MATCH_p); 
09025                                                                 goto MATCH_label_a352; 
09026                                                                 
09027                                                                 break;
09028                                                               default: assert(0);
09029                                                             } /* (MATCH_w_8_24 & 0x7) 
09030                                                                   -- r_m at 24 --*/ 
09031                                                           break;
09032                                                         case 1: 
09033                                                           MATCH_w_8_32 = 
09034                                                             getByte(
09035                                                                   4 + 
09036                                                                   MATCH_p); 
09037                                                           if ((MATCH_w_8_24 & 0x7) 
09038                                                                   /* r_m at 24 */ == 4 && 
09039                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09040                                                                   /* index at 32 */ && 
09041                                                             (MATCH_w_8_32 >> 3 & 0x7) 
09042                                                                   /* index at 32 */ < 8)) { 
09043                                                             MATCH_w_8_48 = 
09044                                                               getByte(
09045                                                                     6 + 
09046                                                                     MATCH_p); 
09047                                                             { 
09048                                                               unsigned Eaddr = 
09049                                                                 3 + 
09050                                                                 addressToPC(
09051                                                                             MATCH_p);
09052                                                               int /* [~128..127] */ i8 = 
09053                                                                 sign_extend(
09054                                                                             (MATCH_w_8_48 & 0xff) 
09055                                                                                   /* i8 at 48 */, 
09056                                                                             8);
09057                                                               nextPC = 7 + 
09058                                                               MATCH_p; 
09059                                                               
09060                                                               #line 1019 "machine/pentium/disassembler.m"
09061                                                               
09062 
09063                                                                       sprintf (str,  "BTCiow", DIS_EADDR16, DIS_I8);
09064 
09065                                                               
09066 
09067                                                               
09068                                                               
09069                                                               
09070                                                             }
09071                                                             
09072                                                           } /*opt-block*/
09073                                                           else { 
09074                                                             MATCH_w_8_40 = 
09075                                                               getByte(
09076                                                                     5 + 
09077                                                                     MATCH_p); 
09078                                                             goto MATCH_label_a350; 
09079                                                             
09080                                                           } /*opt-block*/
09081                                                           
09082                                                           break;
09083                                                         case 2: 
09084                                                           MATCH_w_8_32 = 
09085                                                             getByte(
09086                                                                   4 + 
09087                                                                   MATCH_p); 
09088                                                           if ((MATCH_w_8_24 & 0x7) 
09089                                                                   /* r_m at 24 */ == 4 && 
09090                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09091                                                                   /* index at 32 */ && 
09092                                                             (MATCH_w_8_32 >> 3 & 0x7) 
09093                                                                   /* index at 32 */ < 8)) { 
09094                                                             MATCH_w_8_72 = 
09095                                                               getByte(
09096                                                                     9 + 
09097                                                                     MATCH_p); 
09098                                                             goto MATCH_label_a351; 
09099                                                             
09100                                                           } /*opt-block*/
09101                                                           else { 
09102                                                             MATCH_w_8_64 = 
09103                                                               getByte(
09104                                                                     8 + 
09105                                                                     MATCH_p); 
09106                                                             goto MATCH_label_a352; 
09107                                                             
09108                                                           } /*opt-block*/
09109                                                           
09110                                                           break;
09111                                                         case 3: 
09112                                                           MATCH_w_8_32 = 
09113                                                             getByte(
09114                                                                   4 + 
09115                                                                   MATCH_p); 
09116                                                           goto MATCH_label_a349; 
09117                                                           
09118                                                           break;
09119                                                         default: assert(0);
09120                                                       } /* (MATCH_w_8_24 >> 6 & 0x3) 
09121                                                             -- mod at 24 --*/ 
09122                                                     break;
09123                                                   default: assert(0);
09124                                                 } /* (MATCH_w_8_24 >> 3 & 0x7) 
09125                                                       -- reg_opcode at 24 --*/ 
09126                                               
09127                                             } /*opt-block*/
09128                                             else 
09129                                               goto MATCH_label_a39;  /*opt-block+*/
09130                                             break;
09131                                           case 3: 
09132                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
09133                                                     /* page at 16 */ == 1) { 
09134                                               MATCH_w_8_24 = 
09135                                                 getByte(3 + MATCH_p); 
09136                                               
09137                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
09138                                                       /* mod at 24 */) {
09139                                                   case 0: 
09140                                                     
09141                                                       switch((MATCH_w_8_24 & 0x7) 
09142                                                             /* r_m at 24 */) {
09143                                                         case 0: case 1: 
09144                                                         case 2: case 3: 
09145                                                         case 6: case 7: 
09146                                                           goto MATCH_label_a357; 
09147                                                           
09148                                                           break;
09149                                                         case 4: 
09150                                                           MATCH_w_8_32 = 
09151                                                             getByte(
09152                                                                   4 + 
09153                                                                   MATCH_p); 
09154                                                           if ((MATCH_w_8_32 & 0x7) 
09155                                                                   /* base at 32 */ == 5 && 
09156                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09157                                                                   /* index at 32 */ && 
09158                                                             (MATCH_w_8_32 >> 3 & 0x7) 
09159                                                                   /* index at 32 */ < 8)) 
09160                                                             goto MATCH_label_a359;  /*opt-block+*/
09161                                                           else 
09162                                                             goto MATCH_label_a358;  /*opt-block+*/
09163                                                           
09164                                                           break;
09165                                                         case 5: 
09166                                                           goto MATCH_label_a360; 
09167                                                           
09168                                                           break;
09169                                                         default: assert(0);
09170                                                       } /* (MATCH_w_8_24 & 0x7) 
09171                                                             -- r_m at 24 --*/ 
09172                                                     break;
09173                                                   case 1: 
09174                                                     MATCH_w_8_32 = 
09175                                                       getByte(4 + MATCH_p); 
09176                                                     if ((MATCH_w_8_24 & 0x7) 
09177                                                             /* r_m at 24 */ == 4 && 
09178                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09179                                                             /* index at 32 */ && 
09180                                                       (MATCH_w_8_32 >> 3 & 0x7) 
09181                                                             /* index at 32 */ < 8)) { 
09182                                                       unsigned Eaddr = 
09183                                                         3 + 
09184                                                         addressToPC(MATCH_p);
09185                                                       unsigned reg = 
09186                                                         (MATCH_w_8_24 >> 3 & 0x7) 
09187                                                               /* reg_opcode at 24 */;
09188                                                       nextPC = 6 + MATCH_p; 
09189                                                       
09190                                                       #line 1025 "machine/pentium/disassembler.m"
09191                                                       
09192 
09193                                                               sprintf (str,  "BTCow", DIS_EADDR16, DIS_REG16);
09194 
09195                                                       
09196 
09197                                                       
09198                                                       
09199                                                       
09200                                                     } /*opt-block*//*opt-block+*/
09201                                                     else 
09202                                                       goto MATCH_label_a358;  /*opt-block+*/
09203                                                     
09204                                                     break;
09205                                                   case 2: 
09206                                                     MATCH_w_8_32 = 
09207                                                       getByte(4 + MATCH_p); 
09208                                                     if ((MATCH_w_8_24 & 0x7) 
09209                                                             /* r_m at 24 */ == 4 && 
09210                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09211                                                             /* index at 32 */ && 
09212                                                       (MATCH_w_8_32 >> 3 & 0x7) 
09213                                                             /* index at 32 */ < 8)) 
09214                                                       goto MATCH_label_a359;  /*opt-block+*/
09215                                                     else 
09216                                                       goto MATCH_label_a360;  /*opt-block+*/
09217                                                     
09218                                                     break;
09219                                                   case 3: 
09220                                                     goto MATCH_label_a357; 
09221                                                     
09222                                                     break;
09223                                                   default: assert(0);
09224                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
09225                                                       -- mod at 24 --*/ 
09226                                               
09227                                             } /*opt-block*/
09228                                             else { 
09229                                               MATCH_w_8_24 = 
09230                                                 getByte(3 + MATCH_p); 
09231                                               
09232                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
09233                                                       /* mod at 24 */) {
09234                                                   case 0: 
09235                                                     
09236                                                       switch((MATCH_w_8_24 & 0x7) 
09237                                                             /* r_m at 24 */) {
09238                                                         case 0: case 1: 
09239                                                         case 2: case 3: 
09240                                                         case 6: case 7: 
09241                                                           goto MATCH_label_a353; 
09242                                                           
09243                                                           break;
09244                                                         case 4: 
09245                                                           MATCH_w_8_32 = 
09246                                                             getByte(
09247                                                                   4 + 
09248                                                                   MATCH_p); 
09249                                                           if ((MATCH_w_8_32 & 0x7) 
09250                                                                   /* base at 32 */ == 5 && 
09251                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09252                                                                   /* index at 32 */ && 
09253                                                             (MATCH_w_8_32 >> 3 & 0x7) 
09254                                                                   /* index at 32 */ < 8)) 
09255                                                             goto MATCH_label_a355;  /*opt-block+*/
09256                                                           else 
09257                                                             goto MATCH_label_a354;  /*opt-block+*/
09258                                                           
09259                                                           break;
09260                                                         case 5: 
09261                                                           goto MATCH_label_a356; 
09262                                                           
09263                                                           break;
09264                                                         default: assert(0);
09265                                                       } /* (MATCH_w_8_24 & 0x7) 
09266                                                             -- r_m at 24 --*/ 
09267                                                     break;
09268                                                   case 1: 
09269                                                     MATCH_w_8_32 = 
09270                                                       getByte(4 + MATCH_p); 
09271                                                     if ((MATCH_w_8_24 & 0x7) 
09272                                                             /* r_m at 24 */ == 4 && 
09273                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09274                                                             /* index at 32 */ && 
09275                                                       (MATCH_w_8_32 >> 3 & 0x7) 
09276                                                             /* index at 32 */ < 8)) { 
09277                                                       unsigned Eaddr = 
09278                                                         3 + 
09279                                                         addressToPC(MATCH_p);
09280                                                       unsigned reg = 
09281                                                         (MATCH_w_8_24 >> 3 & 0x7) 
09282                                                               /* reg_opcode at 24 */;
09283                                                       nextPC = 6 + MATCH_p; 
09284                                                       
09285                                                       #line 1013 "machine/pentium/disassembler.m"
09286                                                       
09287 
09288                                                               sprintf (str,  "BTRow", DIS_EADDR16, DIS_REG16);
09289 
09290                                                       
09291 
09292                                                       
09293                                                       
09294                                                       
09295                                                     } /*opt-block*//*opt-block+*/
09296                                                     else 
09297                                                       goto MATCH_label_a354;  /*opt-block+*/
09298                                                     
09299                                                     break;
09300                                                   case 2: 
09301                                                     MATCH_w_8_32 = 
09302                                                       getByte(4 + MATCH_p); 
09303                                                     if ((MATCH_w_8_24 & 0x7) 
09304                                                             /* r_m at 24 */ == 4 && 
09305                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09306                                                             /* index at 32 */ && 
09307                                                       (MATCH_w_8_32 >> 3 & 0x7) 
09308                                                             /* index at 32 */ < 8)) 
09309                                                       goto MATCH_label_a355;  /*opt-block+*/
09310                                                     else 
09311                                                       goto MATCH_label_a356;  /*opt-block+*/
09312                                                     
09313                                                     break;
09314                                                   case 3: 
09315                                                     goto MATCH_label_a353; 
09316                                                     
09317                                                     break;
09318                                                   default: assert(0);
09319                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
09320                                                       -- mod at 24 --*/ 
09321                                               
09322                                             } /*opt-block*/
09323                                             break;
09324                                           case 4: 
09325                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
09326                                                     /* page at 16 */ == 1) { 
09327                                               MATCH_w_8_24 = 
09328                                                 getByte(3 + MATCH_p); 
09329                                               
09330                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
09331                                                       /* mod at 24 */) {
09332                                                   case 0: 
09333                                                     
09334                                                       switch((MATCH_w_8_24 & 0x7) 
09335                                                             /* r_m at 24 */) {
09336                                                         case 0: case 1: 
09337                                                         case 2: case 3: 
09338                                                         case 6: case 7: 
09339                                                           goto MATCH_label_a361; 
09340                                                           
09341                                                           break;
09342                                                         case 4: 
09343                                                           MATCH_w_8_32 = 
09344                                                             getByte(
09345                                                                   4 + 
09346                                                                   MATCH_p); 
09347                                                           if ((MATCH_w_8_32 & 0x7) 
09348                                                                   /* base at 32 */ == 5 && 
09349                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09350                                                                   /* index at 32 */ && 
09351                                                             (MATCH_w_8_32 >> 3 & 0x7) 
09352                                                                   /* index at 32 */ < 8)) 
09353                                                             goto MATCH_label_a363;  /*opt-block+*/
09354                                                           else 
09355                                                             goto MATCH_label_a362;  /*opt-block+*/
09356                                                           
09357                                                           break;
09358                                                         case 5: 
09359                                                           goto MATCH_label_a364; 
09360                                                           
09361                                                           break;
09362                                                         default: assert(0);
09363                                                       } /* (MATCH_w_8_24 & 0x7) 
09364                                                             -- r_m at 24 --*/ 
09365                                                     break;
09366                                                   case 1: 
09367                                                     MATCH_w_8_32 = 
09368                                                       getByte(4 + MATCH_p); 
09369                                                     if ((MATCH_w_8_24 & 0x7) 
09370                                                             /* r_m at 24 */ == 4 && 
09371                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09372                                                             /* index at 32 */ && 
09373                                                       (MATCH_w_8_32 >> 3 & 0x7) 
09374                                                             /* index at 32 */ < 8)) { 
09375                                                       unsigned Eaddr = 
09376                                                         3 + 
09377                                                         addressToPC(MATCH_p);
09378                                                       unsigned reg = 
09379                                                         (MATCH_w_8_24 >> 3 & 0x7) 
09380                                                               /* reg_opcode at 24 */;
09381                                                       nextPC = 6 + MATCH_p; 
09382                                                       
09383                                                       #line 1052 "machine/pentium/disassembler.m"
09384                                                       
09385 
09386                                                               sprintf (str,  "BSFow", DIS_REG16, DIS_EADDR16);
09387 
09388                                                       
09389 
09390                                                           // Not "user" instructions:
09391 
09392                                                       //  | BOUNDod(reg, Mem) =>
09393 
09394                                                       //      sprintf (str,  "BOUNDod", DIS_REG32, DIS_MEM);
09395 
09396                                                       
09397 
09398                                                       //  | BOUNDow(reg, Mem) =>
09399 
09400                                                       //      sprintf (str,  "BOUNDow", DIS_REG16, DIS_MEM);
09401 
09402                                                       
09403 
09404                                                       //    | ARPL(Eaddr, reg ) =>
09405 
09406                                                       //        unused(Eaddr); unused(reg);
09407 
09408                                                       //        sprintf (str,  "UNIMP");
09409 
09410                                                       
09411 
09412                                                       //    | AAS() =>
09413 
09414                                                       //        sprintf (str,  "AAS");
09415 
09416                                                       
09417 
09418                                                       //    | AAM() =>
09419 
09420                                                       //        sprintf (str,  "AAM");
09421 
09422                                                       
09423 
09424                                                       //    | AAD() =>
09425 
09426                                                       //        sprintf (str,  "AAD");
09427 
09428                                                       
09429 
09430                                                       //    | AAA() =>
09431 
09432                                                       //        sprintf (str,  "AAA");
09433 
09434                                                       
09435 
09436                                                       
09437                                                       
09438                                                       
09439                                                     } /*opt-block*//*opt-block+*/
09440                                                     else 
09441                                                       goto MATCH_label_a362;  /*opt-block+*/
09442                                                     
09443                                                     break;
09444                                                   case 2: 
09445                                                     MATCH_w_8_32 = 
09446                                                       getByte(4 + MATCH_p); 
09447                                                     if ((MATCH_w_8_24 & 0x7) 
09448                                                             /* r_m at 24 */ == 4 && 
09449                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09450                                                             /* index at 32 */ && 
09451                                                       (MATCH_w_8_32 >> 3 & 0x7) 
09452                                                             /* index at 32 */ < 8)) 
09453                                                       goto MATCH_label_a363;  /*opt-block+*/
09454                                                     else 
09455                                                       goto MATCH_label_a364;  /*opt-block+*/
09456                                                     
09457                                                     break;
09458                                                   case 3: 
09459                                                     goto MATCH_label_a361; 
09460                                                     
09461                                                     break;
09462                                                   default: assert(0);
09463                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
09464                                                       -- mod at 24 --*/ 
09465                                               
09466                                             } /*opt-block*/
09467                                             else 
09468                                               goto MATCH_label_a39;  /*opt-block+*/
09469                                             break;
09470                                           case 5: 
09471                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
09472                                                     /* page at 16 */ == 1) { 
09473                                               MATCH_w_8_24 = 
09474                                                 getByte(3 + MATCH_p); 
09475                                               
09476                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
09477                                                       /* mod at 24 */) {
09478                                                   case 0: 
09479                                                     
09480                                                       switch((MATCH_w_8_24 & 0x7) 
09481                                                             /* r_m at 24 */) {
09482                                                         case 0: case 1: 
09483                                                         case 2: case 3: 
09484                                                         case 6: case 7: 
09485                                                           goto MATCH_label_a365; 
09486                                                           
09487                                                           break;
09488                                                         case 4: 
09489                                                           MATCH_w_8_32 = 
09490                                                             getByte(
09491                                                                   4 + 
09492                                                                   MATCH_p); 
09493                                                           if ((MATCH_w_8_32 & 0x7) 
09494                                                                   /* base at 32 */ == 5 && 
09495                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09496                                                                   /* index at 32 */ && 
09497                                                             (MATCH_w_8_32 >> 3 & 0x7) 
09498                                                                   /* index at 32 */ < 8)) 
09499                                                             goto MATCH_label_a367;  /*opt-block+*/
09500                                                           else 
09501                                                             goto MATCH_label_a366;  /*opt-block+*/
09502                                                           
09503                                                           break;
09504                                                         case 5: 
09505                                                           goto MATCH_label_a368; 
09506                                                           
09507                                                           break;
09508                                                         default: assert(0);
09509                                                       } /* (MATCH_w_8_24 & 0x7) 
09510                                                             -- r_m at 24 --*/ 
09511                                                     break;
09512                                                   case 1: 
09513                                                     MATCH_w_8_32 = 
09514                                                       getByte(4 + MATCH_p); 
09515                                                     if ((MATCH_w_8_24 & 0x7) 
09516                                                             /* r_m at 24 */ == 4 && 
09517                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09518                                                             /* index at 32 */ && 
09519                                                       (MATCH_w_8_32 >> 3 & 0x7) 
09520                                                             /* index at 32 */ < 8)) { 
09521                                                       unsigned Eaddr = 
09522                                                         3 + 
09523                                                         addressToPC(MATCH_p);
09524                                                       unsigned reg = 
09525                                                         (MATCH_w_8_24 >> 3 & 0x7) 
09526                                                               /* reg_opcode at 24 */;
09527                                                       nextPC = 6 + MATCH_p; 
09528                                                       
09529                                                       #line 1046 "machine/pentium/disassembler.m"
09530                                                       
09531 
09532                                                               sprintf (str,  "BSRow", DIS_REG16, DIS_EADDR16);
09533 
09534                                                       
09535 
09536                                                       
09537                                                       
09538                                                       
09539                                                     } /*opt-block*//*opt-block+*/
09540                                                     else 
09541                                                       goto MATCH_label_a366;  /*opt-block+*/
09542                                                     
09543                                                     break;
09544                                                   case 2: 
09545                                                     MATCH_w_8_32 = 
09546                                                       getByte(4 + MATCH_p); 
09547                                                     if ((MATCH_w_8_24 & 0x7) 
09548                                                             /* r_m at 24 */ == 4 && 
09549                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09550                                                             /* index at 32 */ && 
09551                                                       (MATCH_w_8_32 >> 3 & 0x7) 
09552                                                             /* index at 32 */ < 8)) 
09553                                                       goto MATCH_label_a367;  /*opt-block+*/
09554                                                     else 
09555                                                       goto MATCH_label_a368;  /*opt-block+*/
09556                                                     
09557                                                     break;
09558                                                   case 3: 
09559                                                     goto MATCH_label_a365; 
09560                                                     
09561                                                     break;
09562                                                   default: assert(0);
09563                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
09564                                                       -- mod at 24 --*/ 
09565                                               
09566                                             } /*opt-block*/
09567                                             else 
09568                                               goto MATCH_label_a39;  /*opt-block+*/
09569                                             break;
09570                                           case 6: 
09571                                             if ((MATCH_w_8_16 >> 3 & 0x1) 
09572                                                     /* page at 16 */ == 1) { 
09573                                               MATCH_w_8_24 = 
09574                                                 getByte(3 + MATCH_p); 
09575                                               
09576                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
09577                                                       /* mod at 24 */) {
09578                                                   case 0: 
09579                                                     
09580                                                       switch((MATCH_w_8_24 & 0x7) 
09581                                                             /* r_m at 24 */) {
09582                                                         case 0: case 1: 
09583                                                         case 2: case 3: 
09584                                                         case 6: case 7: 
09585                                                           goto MATCH_label_a373; 
09586                                                           
09587                                                           break;
09588                                                         case 4: 
09589                                                           MATCH_w_8_32 = 
09590                                                             getByte(
09591                                                                   4 + 
09592                                                                   MATCH_p); 
09593                                                           if ((MATCH_w_8_32 & 0x7) 
09594                                                                   /* base at 32 */ == 5 && 
09595                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09596                                                                   /* index at 32 */ && 
09597                                                             (MATCH_w_8_32 >> 3 & 0x7) 
09598                                                                   /* index at 32 */ < 8)) 
09599                                                             goto MATCH_label_a375;  /*opt-block+*/
09600                                                           else 
09601                                                             goto MATCH_label_a374;  /*opt-block+*/
09602                                                           
09603                                                           break;
09604                                                         case 5: 
09605                                                           goto MATCH_label_a376; 
09606                                                           
09607                                                           break;
09608                                                         default: assert(0);
09609                                                       } /* (MATCH_w_8_24 & 0x7) 
09610                                                             -- r_m at 24 --*/ 
09611                                                     break;
09612                                                   case 1: 
09613                                                     MATCH_w_8_32 = 
09614                                                       getByte(4 + MATCH_p); 
09615                                                     if ((MATCH_w_8_24 & 0x7) 
09616                                                             /* r_m at 24 */ == 4 && 
09617                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09618                                                             /* index at 32 */ && 
09619                                                       (MATCH_w_8_32 >> 3 & 0x7) 
09620                                                             /* index at 32 */ < 8)) { 
09621                                                       unsigned Eaddr = 
09622                                                         3 + 
09623                                                         addressToPC(MATCH_p);
09624                                                       unsigned r16 = 
09625                                                         (MATCH_w_8_24 >> 3 & 0x7) 
09626                                                               /* reg_opcode at 24 */;
09627                                                       nextPC = 6 + MATCH_p; 
09628                                                       
09629                                                       #line 657 "machine/pentium/disassembler.m"
09630                                                       
09631 
09632                                                               sprintf (str,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
09633 
09634                                                       
09635 
09636                                                       
09637                                                       
09638                                                       
09639                                                     } /*opt-block*//*opt-block+*/
09640                                                     else 
09641                                                       goto MATCH_label_a374;  /*opt-block+*/
09642                                                     
09643                                                     break;
09644                                                   case 2: 
09645                                                     MATCH_w_8_32 = 
09646                                                       getByte(4 + MATCH_p); 
09647                                                     if ((MATCH_w_8_24 & 0x7) 
09648                                                             /* r_m at 24 */ == 4 && 
09649                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09650                                                             /* index at 32 */ && 
09651                                                       (MATCH_w_8_32 >> 3 & 0x7) 
09652                                                             /* index at 32 */ < 8)) 
09653                                                       goto MATCH_label_a375;  /*opt-block+*/
09654                                                     else 
09655                                                       goto MATCH_label_a376;  /*opt-block+*/
09656                                                     
09657                                                     break;
09658                                                   case 3: 
09659                                                     goto MATCH_label_a373; 
09660                                                     
09661                                                     break;
09662                                                   default: assert(0);
09663                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
09664                                                       -- mod at 24 --*/ 
09665                                               
09666                                             } /*opt-block*/
09667                                             else { 
09668                                               MATCH_w_8_24 = 
09669                                                 getByte(3 + MATCH_p); 
09670                                               
09671                                                 switch((MATCH_w_8_24 >> 6 & 0x3) 
09672                                                       /* mod at 24 */) {
09673                                                   case 0: 
09674                                                     
09675                                                       switch((MATCH_w_8_24 & 0x7) 
09676                                                             /* r_m at 24 */) {
09677                                                         case 0: case 1: 
09678                                                         case 2: case 3: 
09679                                                         case 6: case 7: 
09680                                                           goto MATCH_label_a369; 
09681                                                           
09682                                                           break;
09683                                                         case 4: 
09684                                                           MATCH_w_8_32 = 
09685                                                             getByte(
09686                                                                   4 + 
09687                                                                   MATCH_p); 
09688                                                           if ((MATCH_w_8_32 & 0x7) 
09689                                                                   /* base at 32 */ == 5 && 
09690                                                             (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09691                                                                   /* index at 32 */ && 
09692                                                             (MATCH_w_8_32 >> 3 & 0x7) 
09693                                                                   /* index at 32 */ < 8)) 
09694                                                             goto MATCH_label_a371;  /*opt-block+*/
09695                                                           else 
09696                                                             goto MATCH_label_a370;  /*opt-block+*/
09697                                                           
09698                                                           break;
09699                                                         case 5: 
09700                                                           goto MATCH_label_a372; 
09701                                                           
09702                                                           break;
09703                                                         default: assert(0);
09704                                                       } /* (MATCH_w_8_24 & 0x7) 
09705                                                             -- r_m at 24 --*/ 
09706                                                     break;
09707                                                   case 1: 
09708                                                     MATCH_w_8_32 = 
09709                                                       getByte(4 + MATCH_p); 
09710                                                     if ((MATCH_w_8_24 & 0x7) 
09711                                                             /* r_m at 24 */ == 4 && 
09712                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09713                                                             /* index at 32 */ && 
09714                                                       (MATCH_w_8_32 >> 3 & 0x7) 
09715                                                             /* index at 32 */ < 8)) { 
09716                                                       unsigned Eaddr = 
09717                                                         3 + 
09718                                                         addressToPC(MATCH_p);
09719                                                       unsigned r16 = 
09720                                                         (MATCH_w_8_24 >> 3 & 0x7) 
09721                                                               /* reg_opcode at 24 */;
09722                                                       nextPC = 6 + MATCH_p; 
09723                                                       
09724                                                       #line 648 "machine/pentium/disassembler.m"
09725                                                       
09726 
09727                                                               sprintf (str,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
09728 
09729                                                       
09730 
09731                                                       
09732                                                       
09733                                                       
09734                                                     } /*opt-block*//*opt-block+*/
09735                                                     else 
09736                                                       goto MATCH_label_a370;  /*opt-block+*/
09737                                                     
09738                                                     break;
09739                                                   case 2: 
09740                                                     MATCH_w_8_32 = 
09741                                                       getByte(4 + MATCH_p); 
09742                                                     if ((MATCH_w_8_24 & 0x7) 
09743                                                             /* r_m at 24 */ == 4 && 
09744                                                       (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09745                                                             /* index at 32 */ && 
09746                                                       (MATCH_w_8_32 >> 3 & 0x7) 
09747                                                             /* index at 32 */ < 8)) 
09748                                                       goto MATCH_label_a371;  /*opt-block+*/
09749                                                     else 
09750                                                       goto MATCH_label_a372;  /*opt-block+*/
09751                                                     
09752                                                     break;
09753                                                   case 3: 
09754                                                     goto MATCH_label_a369; 
09755                                                     
09756                                                     break;
09757                                                   default: assert(0);
09758                                                 } /* (MATCH_w_8_24 >> 6 & 0x3) 
09759                                                       -- mod at 24 --*/ 
09760                                               
09761                                             } /*opt-block*/
09762                                             break;
09763                                           default: assert(0);
09764                                         } /* (MATCH_w_8_16 & 0x7) 
09765                                               -- col at 16 --*/ 
09766                                       break;
09767                                     case 12: 
09768                                       if ((MATCH_w_8_16 & 0x7) 
09769                                               /* col at 16 */ == 1) 
09770                                         if ((MATCH_w_8_16 >> 3 & 0x1) 
09771                                                 /* page at 16 */ == 1) 
09772                                           goto MATCH_label_a39;  /*opt-block+*/
09773                                         else { 
09774                                           MATCH_w_8_24 = 
09775                                             getByte(3 + MATCH_p); 
09776                                           
09777                                             switch((MATCH_w_8_24 >> 6 & 0x3) 
09778                                                   /* mod at 24 */) {
09779                                               case 0: 
09780                                                 
09781                                                   switch((MATCH_w_8_24 & 0x7) 
09782                                                         /* r_m at 24 */) {
09783                                                     case 0: case 1: case 2: 
09784                                                     case 3: case 6: case 7: 
09785                                                       goto MATCH_label_a377; 
09786                                                       
09787                                                       break;
09788                                                     case 4: 
09789                                                       MATCH_w_8_32 = 
09790                                                         getByte(4 + MATCH_p); 
09791                                                       if ((MATCH_w_8_32 & 0x7) 
09792                                                               /* base at 32 */ == 5 && 
09793                                                         (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09794                                                               /* index at 32 */ && 
09795                                                         (MATCH_w_8_32 >> 3 & 0x7) 
09796                                                               /* index at 32 */ < 8)) 
09797                                                         goto MATCH_label_a379;  /*opt-block+*/
09798                                                       else 
09799                                                         goto MATCH_label_a378;  /*opt-block+*/
09800                                                       
09801                                                       break;
09802                                                     case 5: 
09803                                                       goto MATCH_label_a380; 
09804                                                       
09805                                                       break;
09806                                                     default: assert(0);
09807                                                   } /* (MATCH_w_8_24 & 0x7) 
09808                                                         -- r_m at 24 --*/ 
09809                                                 break;
09810                                               case 1: 
09811                                                 MATCH_w_8_32 = 
09812                                                   getByte(4 + MATCH_p); 
09813                                                 if ((MATCH_w_8_24 & 0x7) 
09814                                                         /* r_m at 24 */ == 4 && 
09815                                                   (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09816                                                         /* index at 32 */ && 
09817                                                   (MATCH_w_8_32 >> 3 & 0x7) 
09818                                                         /* index at 32 */ < 8)) { 
09819                                                   unsigned Eaddr = 
09820                                                     3 + addressToPC(MATCH_p);
09821                                                   unsigned reg = 
09822                                                     (MATCH_w_8_24 >> 3 & 0x7) 
09823                                                           /* reg_opcode at 24 */;
09824                                                   nextPC = 6 + MATCH_p; 
09825                                                   
09826                                                   #line 74 "machine/pentium/disassembler.m"
09827                                                   
09828 
09829                                                           sprintf (str,  "XADD.Ev.Gvow", DIS_EADDR16, DIS_REG16);
09830 
09831                                                   
09832 
09833                                                   
09834                                                   
09835                                                   
09836                                                 } /*opt-block*//*opt-block+*/
09837                                                 else 
09838                                                   goto MATCH_label_a378;  /*opt-block+*/
09839                                                 
09840                                                 break;
09841                                               case 2: 
09842                                                 MATCH_w_8_32 = 
09843                                                   getByte(4 + MATCH_p); 
09844                                                 if ((MATCH_w_8_24 & 0x7) 
09845                                                         /* r_m at 24 */ == 4 && 
09846                                                   (0 <= (MATCH_w_8_32 >> 3 & 0x7) 
09847                                                         /* index at 32 */ && 
09848                                                   (MATCH_w_8_32 >> 3 & 0x7) 
09849                                                         /* index at 32 */ < 8)) 
09850                                                   goto MATCH_label_a379;  /*opt-block+*/
09851                                                 else 
09852                                                   goto MATCH_label_a380;  /*opt-block+*/
09853                                                 
09854                                                 break;
09855                                               case 3: 
09856                                                 goto MATCH_label_a377; break;
09857                                               default: assert(0);
09858                                             } /* (MATCH_w_8_24 >> 6 & 0x3) 
09859                                                   -- mod at 24 --*/ 
09860                                           
09861                                         } /*opt-block*/ 
09862                                       else 
09863                                         goto MATCH_label_a39;  /*opt-block+*/
09864                                       break;
09865                                     default: assert(0);
09866                                   } /* (MATCH_w_8_16 >> 4 & 0xf) 
09867                                         -- row at 16 --*/ 
09868                                 
09869                               } /*opt-block*/
09870                               else 
09871                                 goto MATCH_label_a39;  /*opt-block+*/
09872                               break;
09873                             default: assert(0);
09874                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
09875                         break;
09876                       case 1: 
09877                         
09878                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
09879                             case 0: case 2: case 4: case 6: case 7: 
09880                               goto MATCH_label_a39; break;
09881                             case 1: 
09882                               if ((MATCH_w_8_8 >> 3 & 0x1) 
09883                                       /* page at 8 */ == 1) { 
09884                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
09885                                 
09886                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
09887                                         /* mod at 16 */) {
09888                                     case 0: 
09889                                       
09890                                         switch((MATCH_w_8_16 & 0x7) 
09891                                               /* r_m at 16 */) {
09892                                           case 0: case 1: case 2: case 3: 
09893                                           case 6: case 7: 
09894                                             goto MATCH_label_a385; break;
09895                                           case 4: 
09896                                             MATCH_w_8_24 = 
09897                                               getByte(3 + MATCH_p); 
09898                                             if ((MATCH_w_8_24 & 0x7) 
09899                                                     /* base at 24 */ == 5 && 
09900                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
09901                                                     /* index at 24 */ && 
09902                                               (MATCH_w_8_24 >> 3 & 0x7) 
09903                                                     /* index at 24 */ < 8)) 
09904                                               goto MATCH_label_a387;  /*opt-block+*/
09905                                             else 
09906                                               goto MATCH_label_a386;  /*opt-block+*/
09907                                             
09908                                             break;
09909                                           case 5: 
09910                                             goto MATCH_label_a388; break;
09911                                           default: assert(0);
09912                                         } /* (MATCH_w_8_16 & 0x7) 
09913                                               -- r_m at 16 --*/ 
09914                                       break;
09915                                     case 1: 
09916                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
09917                                       if ((MATCH_w_8_16 & 0x7) 
09918                                               /* r_m at 16 */ == 4 && 
09919                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
09920                                               /* index at 24 */ && 
09921                                         (MATCH_w_8_24 >> 3 & 0x7) 
09922                                               /* index at 24 */ < 8)) { 
09923                                         unsigned Eaddr = 
09924                                           2 + addressToPC(MATCH_p);
09925                                         unsigned reg = 
09926                                           (MATCH_w_8_16 >> 3 & 0x7) 
09927                                                 /* reg_opcode at 16 */;
09928                                         nextPC = 5 + MATCH_p; 
09929                                         
09930                                         #line 1177 "machine/pentium/disassembler.m"
09931                                         
09932 
09933                                                 sprintf (str,  "SBBmrow", DIS_EADDR16, DIS_REG16);
09934 
09935                                         
09936 
09937                                         
09938                                         
09939                                         
09940                                       } /*opt-block*//*opt-block+*/
09941                                       else 
09942                                         goto MATCH_label_a386;  /*opt-block+*/
09943                                       
09944                                       break;
09945                                     case 2: 
09946                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
09947                                       if ((MATCH_w_8_16 & 0x7) 
09948                                               /* r_m at 16 */ == 4 && 
09949                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
09950                                               /* index at 24 */ && 
09951                                         (MATCH_w_8_24 >> 3 & 0x7) 
09952                                               /* index at 24 */ < 8)) 
09953                                         goto MATCH_label_a387;  /*opt-block+*/
09954                                       else 
09955                                         goto MATCH_label_a388;  /*opt-block+*/
09956                                       
09957                                       break;
09958                                     case 3: 
09959                                       goto MATCH_label_a385; break;
09960                                     default: assert(0);
09961                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
09962                                         -- mod at 16 --*/ 
09963                                 
09964                               } /*opt-block*/
09965                               else { 
09966                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
09967                                 
09968                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
09969                                         /* mod at 16 */) {
09970                                     case 0: 
09971                                       
09972                                         switch((MATCH_w_8_16 & 0x7) 
09973                                               /* r_m at 16 */) {
09974                                           case 0: case 1: case 2: case 3: 
09975                                           case 6: case 7: 
09976                                             goto MATCH_label_a381; break;
09977                                           case 4: 
09978                                             MATCH_w_8_24 = 
09979                                               getByte(3 + MATCH_p); 
09980                                             if ((MATCH_w_8_24 & 0x7) 
09981                                                     /* base at 24 */ == 5 && 
09982                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
09983                                                     /* index at 24 */ && 
09984                                               (MATCH_w_8_24 >> 3 & 0x7) 
09985                                                     /* index at 24 */ < 8)) 
09986                                               goto MATCH_label_a383;  /*opt-block+*/
09987                                             else 
09988                                               goto MATCH_label_a382;  /*opt-block+*/
09989                                             
09990                                             break;
09991                                           case 5: 
09992                                             goto MATCH_label_a384; break;
09993                                           default: assert(0);
09994                                         } /* (MATCH_w_8_16 & 0x7) 
09995                                               -- r_m at 16 --*/ 
09996                                       break;
09997                                     case 1: 
09998                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
09999                                       if ((MATCH_w_8_16 & 0x7) 
10000                                               /* r_m at 16 */ == 4 && 
10001                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10002                                               /* index at 24 */ && 
10003                                         (MATCH_w_8_24 >> 3 & 0x7) 
10004                                               /* index at 24 */ < 8)) { 
10005                                         unsigned Eaddr = 
10006                                           2 + addressToPC(MATCH_p);
10007                                         unsigned reg = 
10008                                           (MATCH_w_8_16 >> 3 & 0x7) 
10009                                                 /* reg_opcode at 16 */;
10010                                         nextPC = 5 + MATCH_p; 
10011                                         
10012                                         #line 1183 "machine/pentium/disassembler.m"
10013                                         
10014 
10015                                                 sprintf (str,  "ADCmrow", DIS_EADDR16, DIS_REG16);
10016 
10017                                         
10018 
10019                                         
10020                                         
10021                                         
10022                                       } /*opt-block*//*opt-block+*/
10023                                       else 
10024                                         goto MATCH_label_a382;  /*opt-block+*/
10025                                       
10026                                       break;
10027                                     case 2: 
10028                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10029                                       if ((MATCH_w_8_16 & 0x7) 
10030                                               /* r_m at 16 */ == 4 && 
10031                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10032                                               /* index at 24 */ && 
10033                                         (MATCH_w_8_24 >> 3 & 0x7) 
10034                                               /* index at 24 */ < 8)) 
10035                                         goto MATCH_label_a383;  /*opt-block+*/
10036                                       else 
10037                                         goto MATCH_label_a384;  /*opt-block+*/
10038                                       
10039                                       break;
10040                                     case 3: 
10041                                       goto MATCH_label_a381; break;
10042                                     default: assert(0);
10043                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
10044                                         -- mod at 16 --*/ 
10045                                 
10046                               } /*opt-block*/
10047                               break;
10048                             case 3: 
10049                               if ((MATCH_w_8_8 >> 3 & 0x1) 
10050                                       /* page at 8 */ == 1) { 
10051                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
10052                                 
10053                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
10054                                         /* mod at 16 */) {
10055                                     case 0: 
10056                                       
10057                                         switch((MATCH_w_8_16 & 0x7) 
10058                                               /* r_m at 16 */) {
10059                                           case 0: case 1: case 2: case 3: 
10060                                           case 6: case 7: 
10061                                             goto MATCH_label_a393; break;
10062                                           case 4: 
10063                                             MATCH_w_8_24 = 
10064                                               getByte(3 + MATCH_p); 
10065                                             if ((MATCH_w_8_24 & 0x7) 
10066                                                     /* base at 24 */ == 5 && 
10067                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10068                                                     /* index at 24 */ && 
10069                                               (MATCH_w_8_24 >> 3 & 0x7) 
10070                                                     /* index at 24 */ < 8)) 
10071                                               goto MATCH_label_a395;  /*opt-block+*/
10072                                             else 
10073                                               goto MATCH_label_a394;  /*opt-block+*/
10074                                             
10075                                             break;
10076                                           case 5: 
10077                                             goto MATCH_label_a396; break;
10078                                           default: assert(0);
10079                                         } /* (MATCH_w_8_16 & 0x7) 
10080                                               -- r_m at 16 --*/ 
10081                                       break;
10082                                     case 1: 
10083                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10084                                       if ((MATCH_w_8_16 & 0x7) 
10085                                               /* r_m at 16 */ == 4 && 
10086                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10087                                               /* index at 24 */ && 
10088                                         (MATCH_w_8_24 >> 3 & 0x7) 
10089                                               /* index at 24 */ < 8)) { 
10090                                         unsigned Eaddr = 
10091                                           2 + addressToPC(MATCH_p);
10092                                         unsigned reg = 
10093                                           (MATCH_w_8_16 >> 3 & 0x7) 
10094                                                 /* reg_opcode at 16 */;
10095                                         nextPC = 5 + MATCH_p; 
10096                                         
10097                                         #line 1105 "machine/pentium/disassembler.m"
10098                                         
10099 
10100                                                 sprintf (str,  "SBBrmow", DIS_REG16, DIS_EADDR16);
10101 
10102                                         
10103 
10104                                         
10105                                         
10106                                         
10107                                       } /*opt-block*//*opt-block+*/
10108                                       else 
10109                                         goto MATCH_label_a394;  /*opt-block+*/
10110                                       
10111                                       break;
10112                                     case 2: 
10113                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10114                                       if ((MATCH_w_8_16 & 0x7) 
10115                                               /* r_m at 16 */ == 4 && 
10116                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10117                                               /* index at 24 */ && 
10118                                         (MATCH_w_8_24 >> 3 & 0x7) 
10119                                               /* index at 24 */ < 8)) 
10120                                         goto MATCH_label_a395;  /*opt-block+*/
10121                                       else 
10122                                         goto MATCH_label_a396;  /*opt-block+*/
10123                                       
10124                                       break;
10125                                     case 3: 
10126                                       goto MATCH_label_a393; break;
10127                                     default: assert(0);
10128                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
10129                                         -- mod at 16 --*/ 
10130                                 
10131                               } /*opt-block*/
10132                               else { 
10133                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
10134                                 
10135                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
10136                                         /* mod at 16 */) {
10137                                     case 0: 
10138                                       
10139                                         switch((MATCH_w_8_16 & 0x7) 
10140                                               /* r_m at 16 */) {
10141                                           case 0: case 1: case 2: case 3: 
10142                                           case 6: case 7: 
10143                                             goto MATCH_label_a389; break;
10144                                           case 4: 
10145                                             MATCH_w_8_24 = 
10146                                               getByte(3 + MATCH_p); 
10147                                             if ((MATCH_w_8_24 & 0x7) 
10148                                                     /* base at 24 */ == 5 && 
10149                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10150                                                     /* index at 24 */ && 
10151                                               (MATCH_w_8_24 >> 3 & 0x7) 
10152                                                     /* index at 24 */ < 8)) 
10153                                               goto MATCH_label_a391;  /*opt-block+*/
10154                                             else 
10155                                               goto MATCH_label_a390;  /*opt-block+*/
10156                                             
10157                                             break;
10158                                           case 5: 
10159                                             goto MATCH_label_a392; break;
10160                                           default: assert(0);
10161                                         } /* (MATCH_w_8_16 & 0x7) 
10162                                               -- r_m at 16 --*/ 
10163                                       break;
10164                                     case 1: 
10165                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10166                                       if ((MATCH_w_8_16 & 0x7) 
10167                                               /* r_m at 16 */ == 4 && 
10168                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10169                                               /* index at 24 */ && 
10170                                         (MATCH_w_8_24 >> 3 & 0x7) 
10171                                               /* index at 24 */ < 8)) { 
10172                                         unsigned Eaddr = 
10173                                           2 + addressToPC(MATCH_p);
10174                                         unsigned reg = 
10175                                           (MATCH_w_8_16 >> 3 & 0x7) 
10176                                                 /* reg_opcode at 16 */;
10177                                         nextPC = 5 + MATCH_p; 
10178                                         
10179                                         #line 1111 "machine/pentium/disassembler.m"
10180                                         
10181 
10182                                                 sprintf (str,  "ADCrmow", DIS_REG16, DIS_EADDR16);
10183 
10184                                         
10185 
10186                                         
10187                                         
10188                                         
10189                                       } /*opt-block*//*opt-block+*/
10190                                       else 
10191                                         goto MATCH_label_a390;  /*opt-block+*/
10192                                       
10193                                       break;
10194                                     case 2: 
10195                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10196                                       if ((MATCH_w_8_16 & 0x7) 
10197                                               /* r_m at 16 */ == 4 && 
10198                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10199                                               /* index at 24 */ && 
10200                                         (MATCH_w_8_24 >> 3 & 0x7) 
10201                                               /* index at 24 */ < 8)) 
10202                                         goto MATCH_label_a391;  /*opt-block+*/
10203                                       else 
10204                                         goto MATCH_label_a392;  /*opt-block+*/
10205                                       
10206                                       break;
10207                                     case 3: 
10208                                       goto MATCH_label_a389; break;
10209                                     default: assert(0);
10210                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
10211                                         -- mod at 16 --*/ 
10212                                 
10213                               } /*opt-block*/
10214                               break;
10215                             case 5: 
10216                               if ((MATCH_w_8_8 >> 3 & 0x1) 
10217                                       /* page at 8 */ == 1) { 
10218                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
10219                                 { 
10220                                   int /* [~32768..32767] */ i16 = 
10221                                     sign_extend(
10222                                                 (MATCH_w_16_16 & 0xffff) 
10223                                                       /* i16 at 16 */, 16);
10224                                   nextPC = 4 + MATCH_p; 
10225                                   
10226                                   #line 1378 "machine/pentium/disassembler.m"
10227                                   
10228 
10229                                           sprintf (str,  "SBBiAX", DIS_I16);
10230 
10231                                   
10232 
10233                                   
10234                                   
10235                                   
10236                                 }
10237                                 
10238                               } /*opt-block*/
10239                               else { 
10240                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
10241                                 { 
10242                                   int /* [~32768..32767] */ i16 = 
10243                                     sign_extend(
10244                                                 (MATCH_w_16_16 & 0xffff) 
10245                                                       /* i16 at 16 */, 16);
10246                                   nextPC = 4 + MATCH_p; 
10247                                   
10248                                   #line 1381 "machine/pentium/disassembler.m"
10249                                   
10250 
10251                                           sprintf (str,  "ADCiAX", DIS_I16);
10252 
10253                                   
10254 
10255                                   
10256                                   
10257                                   
10258                                 }
10259                                 
10260                               } /*opt-block*/
10261                               
10262                               break;
10263                             default: assert(0);
10264                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
10265                         break;
10266                       case 2: 
10267                         
10268                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
10269                             case 0: case 2: case 4: case 6: case 7: 
10270                               goto MATCH_label_a39; break;
10271                             case 1: 
10272                               if ((MATCH_w_8_8 >> 3 & 0x1) 
10273                                       /* page at 8 */ == 1) { 
10274                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
10275                                 
10276                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
10277                                         /* mod at 16 */) {
10278                                     case 0: 
10279                                       
10280                                         switch((MATCH_w_8_16 & 0x7) 
10281                                               /* r_m at 16 */) {
10282                                           case 0: case 1: case 2: case 3: 
10283                                           case 6: case 7: 
10284                                             goto MATCH_label_a401; break;
10285                                           case 4: 
10286                                             MATCH_w_8_24 = 
10287                                               getByte(3 + MATCH_p); 
10288                                             if ((MATCH_w_8_24 & 0x7) 
10289                                                     /* base at 24 */ == 5 && 
10290                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10291                                                     /* index at 24 */ && 
10292                                               (MATCH_w_8_24 >> 3 & 0x7) 
10293                                                     /* index at 24 */ < 8)) 
10294                                               goto MATCH_label_a403;  /*opt-block+*/
10295                                             else 
10296                                               goto MATCH_label_a402;  /*opt-block+*/
10297                                             
10298                                             break;
10299                                           case 5: 
10300                                             goto MATCH_label_a404; break;
10301                                           default: assert(0);
10302                                         } /* (MATCH_w_8_16 & 0x7) 
10303                                               -- r_m at 16 --*/ 
10304                                       break;
10305                                     case 1: 
10306                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10307                                       if ((MATCH_w_8_16 & 0x7) 
10308                                               /* r_m at 16 */ == 4 && 
10309                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10310                                               /* index at 24 */ && 
10311                                         (MATCH_w_8_24 >> 3 & 0x7) 
10312                                               /* index at 24 */ < 8)) { 
10313                                         unsigned Eaddr = 
10314                                           2 + addressToPC(MATCH_p);
10315                                         unsigned reg = 
10316                                           (MATCH_w_8_16 >> 3 & 0x7) 
10317                                                 /* reg_opcode at 16 */;
10318                                         nextPC = 5 + MATCH_p; 
10319                                         
10320                                         #line 1165 "machine/pentium/disassembler.m"
10321                                         
10322 
10323                                                 sprintf (str,  "SUBmrow", DIS_EADDR16, DIS_REG16);
10324 
10325                                         
10326 
10327                                         
10328                                         
10329                                         
10330                                       } /*opt-block*//*opt-block+*/
10331                                       else 
10332                                         goto MATCH_label_a402;  /*opt-block+*/
10333                                       
10334                                       break;
10335                                     case 2: 
10336                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10337                                       if ((MATCH_w_8_16 & 0x7) 
10338                                               /* r_m at 16 */ == 4 && 
10339                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10340                                               /* index at 24 */ && 
10341                                         (MATCH_w_8_24 >> 3 & 0x7) 
10342                                               /* index at 24 */ < 8)) 
10343                                         goto MATCH_label_a403;  /*opt-block+*/
10344                                       else 
10345                                         goto MATCH_label_a404;  /*opt-block+*/
10346                                       
10347                                       break;
10348                                     case 3: 
10349                                       goto MATCH_label_a401; break;
10350                                     default: assert(0);
10351                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
10352                                         -- mod at 16 --*/ 
10353                                 
10354                               } /*opt-block*/
10355                               else { 
10356                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
10357                                 
10358                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
10359                                         /* mod at 16 */) {
10360                                     case 0: 
10361                                       
10362                                         switch((MATCH_w_8_16 & 0x7) 
10363                                               /* r_m at 16 */) {
10364                                           case 0: case 1: case 2: case 3: 
10365                                           case 6: case 7: 
10366                                             goto MATCH_label_a397; break;
10367                                           case 4: 
10368                                             MATCH_w_8_24 = 
10369                                               getByte(3 + MATCH_p); 
10370                                             if ((MATCH_w_8_24 & 0x7) 
10371                                                     /* base at 24 */ == 5 && 
10372                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10373                                                     /* index at 24 */ && 
10374                                               (MATCH_w_8_24 >> 3 & 0x7) 
10375                                                     /* index at 24 */ < 8)) 
10376                                               goto MATCH_label_a399;  /*opt-block+*/
10377                                             else 
10378                                               goto MATCH_label_a398;  /*opt-block+*/
10379                                             
10380                                             break;
10381                                           case 5: 
10382                                             goto MATCH_label_a400; break;
10383                                           default: assert(0);
10384                                         } /* (MATCH_w_8_16 & 0x7) 
10385                                               -- r_m at 16 --*/ 
10386                                       break;
10387                                     case 1: 
10388                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10389                                       if ((MATCH_w_8_16 & 0x7) 
10390                                               /* r_m at 16 */ == 4 && 
10391                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10392                                               /* index at 24 */ && 
10393                                         (MATCH_w_8_24 >> 3 & 0x7) 
10394                                               /* index at 24 */ < 8)) { 
10395                                         unsigned Eaddr = 
10396                                           2 + addressToPC(MATCH_p);
10397                                         unsigned reg = 
10398                                           (MATCH_w_8_16 >> 3 & 0x7) 
10399                                                 /* reg_opcode at 16 */;
10400                                         nextPC = 5 + MATCH_p; 
10401                                         
10402                                         #line 1171 "machine/pentium/disassembler.m"
10403                                         
10404 
10405                                                 sprintf (str,  "ANDmrow", DIS_EADDR16, DIS_REG16);
10406 
10407                                         
10408 
10409                                         
10410                                         
10411                                         
10412                                       } /*opt-block*//*opt-block+*/
10413                                       else 
10414                                         goto MATCH_label_a398;  /*opt-block+*/
10415                                       
10416                                       break;
10417                                     case 2: 
10418                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10419                                       if ((MATCH_w_8_16 & 0x7) 
10420                                               /* r_m at 16 */ == 4 && 
10421                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10422                                               /* index at 24 */ && 
10423                                         (MATCH_w_8_24 >> 3 & 0x7) 
10424                                               /* index at 24 */ < 8)) 
10425                                         goto MATCH_label_a399;  /*opt-block+*/
10426                                       else 
10427                                         goto MATCH_label_a400;  /*opt-block+*/
10428                                       
10429                                       break;
10430                                     case 3: 
10431                                       goto MATCH_label_a397; break;
10432                                     default: assert(0);
10433                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
10434                                         -- mod at 16 --*/ 
10435                                 
10436                               } /*opt-block*/
10437                               break;
10438                             case 3: 
10439                               if ((MATCH_w_8_8 >> 3 & 0x1) 
10440                                       /* page at 8 */ == 1) { 
10441                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
10442                                 
10443                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
10444                                         /* mod at 16 */) {
10445                                     case 0: 
10446                                       
10447                                         switch((MATCH_w_8_16 & 0x7) 
10448                                               /* r_m at 16 */) {
10449                                           case 0: case 1: case 2: case 3: 
10450                                           case 6: case 7: 
10451                                             goto MATCH_label_a409; break;
10452                                           case 4: 
10453                                             MATCH_w_8_24 = 
10454                                               getByte(3 + MATCH_p); 
10455                                             if ((MATCH_w_8_24 & 0x7) 
10456                                                     /* base at 24 */ == 5 && 
10457                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10458                                                     /* index at 24 */ && 
10459                                               (MATCH_w_8_24 >> 3 & 0x7) 
10460                                                     /* index at 24 */ < 8)) 
10461                                               goto MATCH_label_a411;  /*opt-block+*/
10462                                             else 
10463                                               goto MATCH_label_a410;  /*opt-block+*/
10464                                             
10465                                             break;
10466                                           case 5: 
10467                                             goto MATCH_label_a412; break;
10468                                           default: assert(0);
10469                                         } /* (MATCH_w_8_16 & 0x7) 
10470                                               -- r_m at 16 --*/ 
10471                                       break;
10472                                     case 1: 
10473                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10474                                       if ((MATCH_w_8_16 & 0x7) 
10475                                               /* r_m at 16 */ == 4 && 
10476                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10477                                               /* index at 24 */ && 
10478                                         (MATCH_w_8_24 >> 3 & 0x7) 
10479                                               /* index at 24 */ < 8)) { 
10480                                         unsigned Eaddr = 
10481                                           2 + addressToPC(MATCH_p);
10482                                         unsigned reg = 
10483                                           (MATCH_w_8_16 >> 3 & 0x7) 
10484                                                 /* reg_opcode at 16 */;
10485                                         nextPC = 5 + MATCH_p; 
10486                                         
10487                                         #line 1093 "machine/pentium/disassembler.m"
10488                                         
10489 
10490                                                 sprintf (str,  "SUBrmow", DIS_REG16, DIS_EADDR16);
10491 
10492                                         
10493 
10494                                         
10495                                         
10496                                         
10497                                       } /*opt-block*//*opt-block+*/
10498                                       else 
10499                                         goto MATCH_label_a410;  /*opt-block+*/
10500                                       
10501                                       break;
10502                                     case 2: 
10503                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10504                                       if ((MATCH_w_8_16 & 0x7) 
10505                                               /* r_m at 16 */ == 4 && 
10506                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10507                                               /* index at 24 */ && 
10508                                         (MATCH_w_8_24 >> 3 & 0x7) 
10509                                               /* index at 24 */ < 8)) 
10510                                         goto MATCH_label_a411;  /*opt-block+*/
10511                                       else 
10512                                         goto MATCH_label_a412;  /*opt-block+*/
10513                                       
10514                                       break;
10515                                     case 3: 
10516                                       goto MATCH_label_a409; break;
10517                                     default: assert(0);
10518                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
10519                                         -- mod at 16 --*/ 
10520                                 
10521                               } /*opt-block*/
10522                               else { 
10523                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
10524                                 
10525                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
10526                                         /* mod at 16 */) {
10527                                     case 0: 
10528                                       
10529                                         switch((MATCH_w_8_16 & 0x7) 
10530                                               /* r_m at 16 */) {
10531                                           case 0: case 1: case 2: case 3: 
10532                                           case 6: case 7: 
10533                                             goto MATCH_label_a405; break;
10534                                           case 4: 
10535                                             MATCH_w_8_24 = 
10536                                               getByte(3 + MATCH_p); 
10537                                             if ((MATCH_w_8_24 & 0x7) 
10538                                                     /* base at 24 */ == 5 && 
10539                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10540                                                     /* index at 24 */ && 
10541                                               (MATCH_w_8_24 >> 3 & 0x7) 
10542                                                     /* index at 24 */ < 8)) 
10543                                               goto MATCH_label_a407;  /*opt-block+*/
10544                                             else 
10545                                               goto MATCH_label_a406;  /*opt-block+*/
10546                                             
10547                                             break;
10548                                           case 5: 
10549                                             goto MATCH_label_a408; break;
10550                                           default: assert(0);
10551                                         } /* (MATCH_w_8_16 & 0x7) 
10552                                               -- r_m at 16 --*/ 
10553                                       break;
10554                                     case 1: 
10555                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10556                                       if ((MATCH_w_8_16 & 0x7) 
10557                                               /* r_m at 16 */ == 4 && 
10558                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10559                                               /* index at 24 */ && 
10560                                         (MATCH_w_8_24 >> 3 & 0x7) 
10561                                               /* index at 24 */ < 8)) { 
10562                                         unsigned Eaddr = 
10563                                           2 + addressToPC(MATCH_p);
10564                                         unsigned reg = 
10565                                           (MATCH_w_8_16 >> 3 & 0x7) 
10566                                                 /* reg_opcode at 16 */;
10567                                         nextPC = 5 + MATCH_p; 
10568                                         
10569                                         #line 1099 "machine/pentium/disassembler.m"
10570                                         
10571 
10572                                                 sprintf (str,  "ANDrmow", DIS_REG16, DIS_EADDR16);
10573 
10574                                         
10575 
10576                                         
10577                                         
10578                                         
10579                                       } /*opt-block*//*opt-block+*/
10580                                       else 
10581                                         goto MATCH_label_a406;  /*opt-block+*/
10582                                       
10583                                       break;
10584                                     case 2: 
10585                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10586                                       if ((MATCH_w_8_16 & 0x7) 
10587                                               /* r_m at 16 */ == 4 && 
10588                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10589                                               /* index at 24 */ && 
10590                                         (MATCH_w_8_24 >> 3 & 0x7) 
10591                                               /* index at 24 */ < 8)) 
10592                                         goto MATCH_label_a407;  /*opt-block+*/
10593                                       else 
10594                                         goto MATCH_label_a408;  /*opt-block+*/
10595                                       
10596                                       break;
10597                                     case 3: 
10598                                       goto MATCH_label_a405; break;
10599                                     default: assert(0);
10600                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
10601                                         -- mod at 16 --*/ 
10602                                 
10603                               } /*opt-block*/
10604                               break;
10605                             case 5: 
10606                               if ((MATCH_w_8_8 >> 3 & 0x1) 
10607                                       /* page at 8 */ == 1) { 
10608                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
10609                                 { 
10610                                   int /* [~32768..32767] */ i16 = 
10611                                     sign_extend(
10612                                                 (MATCH_w_16_16 & 0xffff) 
10613                                                       /* i16 at 16 */, 16);
10614                                   nextPC = 4 + MATCH_p; 
10615                                   
10616                                   #line 1372 "machine/pentium/disassembler.m"
10617                                   
10618 
10619                                           sprintf (str,  "SUBiAX", DIS_I16);
10620 
10621                                   
10622 
10623                                   
10624                                   
10625                                   
10626                                 }
10627                                 
10628                               } /*opt-block*/
10629                               else { 
10630                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
10631                                 { 
10632                                   int /* [~32768..32767] */ i16 = 
10633                                     sign_extend(
10634                                                 (MATCH_w_16_16 & 0xffff) 
10635                                                       /* i16 at 16 */, 16);
10636                                   nextPC = 4 + MATCH_p; 
10637                                   
10638                                   #line 1375 "machine/pentium/disassembler.m"
10639                                   
10640 
10641                                           sprintf (str,  "ANDiAX", DIS_I16);
10642 
10643                                   
10644 
10645                                   
10646                                   
10647                                   
10648                                 }
10649                                 
10650                               } /*opt-block*/
10651                               
10652                               break;
10653                             default: assert(0);
10654                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
10655                         break;
10656                       case 3: 
10657                         
10658                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
10659                             case 0: case 2: case 4: case 6: case 7: 
10660                               goto MATCH_label_a39; break;
10661                             case 1: 
10662                               if ((MATCH_w_8_8 >> 3 & 0x1) 
10663                                       /* page at 8 */ == 1) { 
10664                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
10665                                 
10666                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
10667                                         /* mod at 16 */) {
10668                                     case 0: 
10669                                       
10670                                         switch((MATCH_w_8_16 & 0x7) 
10671                                               /* r_m at 16 */) {
10672                                           case 0: case 1: case 2: case 3: 
10673                                           case 6: case 7: 
10674                                             goto MATCH_label_a417; break;
10675                                           case 4: 
10676                                             MATCH_w_8_24 = 
10677                                               getByte(3 + MATCH_p); 
10678                                             if ((MATCH_w_8_24 & 0x7) 
10679                                                     /* base at 24 */ == 5 && 
10680                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10681                                                     /* index at 24 */ && 
10682                                               (MATCH_w_8_24 >> 3 & 0x7) 
10683                                                     /* index at 24 */ < 8)) 
10684                                               goto MATCH_label_a419;  /*opt-block+*/
10685                                             else 
10686                                               goto MATCH_label_a418;  /*opt-block+*/
10687                                             
10688                                             break;
10689                                           case 5: 
10690                                             goto MATCH_label_a420; break;
10691                                           default: assert(0);
10692                                         } /* (MATCH_w_8_16 & 0x7) 
10693                                               -- r_m at 16 --*/ 
10694                                       break;
10695                                     case 1: 
10696                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10697                                       if ((MATCH_w_8_16 & 0x7) 
10698                                               /* r_m at 16 */ == 4 && 
10699                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10700                                               /* index at 24 */ && 
10701                                         (MATCH_w_8_24 >> 3 & 0x7) 
10702                                               /* index at 24 */ < 8)) { 
10703                                         unsigned Eaddr = 
10704                                           2 + addressToPC(MATCH_p);
10705                                         unsigned reg = 
10706                                           (MATCH_w_8_16 >> 3 & 0x7) 
10707                                                 /* reg_opcode at 16 */;
10708                                         nextPC = 5 + MATCH_p; 
10709                                         
10710                                         #line 1153 "machine/pentium/disassembler.m"
10711                                         
10712 
10713                                                 sprintf (str,  "CMPmrow", DIS_EADDR16, DIS_REG16);
10714 
10715                                         
10716 
10717                                         
10718                                         
10719                                         
10720                                       } /*opt-block*//*opt-block+*/
10721                                       else 
10722                                         goto MATCH_label_a418;  /*opt-block+*/
10723                                       
10724                                       break;
10725                                     case 2: 
10726                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10727                                       if ((MATCH_w_8_16 & 0x7) 
10728                                               /* r_m at 16 */ == 4 && 
10729                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10730                                               /* index at 24 */ && 
10731                                         (MATCH_w_8_24 >> 3 & 0x7) 
10732                                               /* index at 24 */ < 8)) 
10733                                         goto MATCH_label_a419;  /*opt-block+*/
10734                                       else 
10735                                         goto MATCH_label_a420;  /*opt-block+*/
10736                                       
10737                                       break;
10738                                     case 3: 
10739                                       goto MATCH_label_a417; break;
10740                                     default: assert(0);
10741                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
10742                                         -- mod at 16 --*/ 
10743                                 
10744                               } /*opt-block*/
10745                               else { 
10746                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
10747                                 
10748                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
10749                                         /* mod at 16 */) {
10750                                     case 0: 
10751                                       
10752                                         switch((MATCH_w_8_16 & 0x7) 
10753                                               /* r_m at 16 */) {
10754                                           case 0: case 1: case 2: case 3: 
10755                                           case 6: case 7: 
10756                                             goto MATCH_label_a413; break;
10757                                           case 4: 
10758                                             MATCH_w_8_24 = 
10759                                               getByte(3 + MATCH_p); 
10760                                             if ((MATCH_w_8_24 & 0x7) 
10761                                                     /* base at 24 */ == 5 && 
10762                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10763                                                     /* index at 24 */ && 
10764                                               (MATCH_w_8_24 >> 3 & 0x7) 
10765                                                     /* index at 24 */ < 8)) 
10766                                               goto MATCH_label_a415;  /*opt-block+*/
10767                                             else 
10768                                               goto MATCH_label_a414;  /*opt-block+*/
10769                                             
10770                                             break;
10771                                           case 5: 
10772                                             goto MATCH_label_a416; break;
10773                                           default: assert(0);
10774                                         } /* (MATCH_w_8_16 & 0x7) 
10775                                               -- r_m at 16 --*/ 
10776                                       break;
10777                                     case 1: 
10778                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10779                                       if ((MATCH_w_8_16 & 0x7) 
10780                                               /* r_m at 16 */ == 4 && 
10781                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10782                                               /* index at 24 */ && 
10783                                         (MATCH_w_8_24 >> 3 & 0x7) 
10784                                               /* index at 24 */ < 8)) { 
10785                                         unsigned Eaddr = 
10786                                           2 + addressToPC(MATCH_p);
10787                                         unsigned reg = 
10788                                           (MATCH_w_8_16 >> 3 & 0x7) 
10789                                                 /* reg_opcode at 16 */;
10790                                         nextPC = 5 + MATCH_p; 
10791                                         
10792                                         #line 1159 "machine/pentium/disassembler.m"
10793                                         
10794 
10795                                                 sprintf (str,  "XORmrow", DIS_EADDR16, DIS_REG16);
10796 
10797                                         
10798 
10799                                         
10800                                         
10801                                         
10802                                       } /*opt-block*//*opt-block+*/
10803                                       else 
10804                                         goto MATCH_label_a414;  /*opt-block+*/
10805                                       
10806                                       break;
10807                                     case 2: 
10808                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10809                                       if ((MATCH_w_8_16 & 0x7) 
10810                                               /* r_m at 16 */ == 4 && 
10811                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10812                                               /* index at 24 */ && 
10813                                         (MATCH_w_8_24 >> 3 & 0x7) 
10814                                               /* index at 24 */ < 8)) 
10815                                         goto MATCH_label_a415;  /*opt-block+*/
10816                                       else 
10817                                         goto MATCH_label_a416;  /*opt-block+*/
10818                                       
10819                                       break;
10820                                     case 3: 
10821                                       goto MATCH_label_a413; break;
10822                                     default: assert(0);
10823                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
10824                                         -- mod at 16 --*/ 
10825                                 
10826                               } /*opt-block*/
10827                               break;
10828                             case 3: 
10829                               if ((MATCH_w_8_8 >> 3 & 0x1) 
10830                                       /* page at 8 */ == 1) { 
10831                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
10832                                 
10833                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
10834                                         /* mod at 16 */) {
10835                                     case 0: 
10836                                       
10837                                         switch((MATCH_w_8_16 & 0x7) 
10838                                               /* r_m at 16 */) {
10839                                           case 0: case 1: case 2: case 3: 
10840                                           case 6: case 7: 
10841                                             goto MATCH_label_a425; break;
10842                                           case 4: 
10843                                             MATCH_w_8_24 = 
10844                                               getByte(3 + MATCH_p); 
10845                                             if ((MATCH_w_8_24 & 0x7) 
10846                                                     /* base at 24 */ == 5 && 
10847                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10848                                                     /* index at 24 */ && 
10849                                               (MATCH_w_8_24 >> 3 & 0x7) 
10850                                                     /* index at 24 */ < 8)) 
10851                                               goto MATCH_label_a427;  /*opt-block+*/
10852                                             else 
10853                                               goto MATCH_label_a426;  /*opt-block+*/
10854                                             
10855                                             break;
10856                                           case 5: 
10857                                             goto MATCH_label_a428; break;
10858                                           default: assert(0);
10859                                         } /* (MATCH_w_8_16 & 0x7) 
10860                                               -- r_m at 16 --*/ 
10861                                       break;
10862                                     case 1: 
10863                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10864                                       if ((MATCH_w_8_16 & 0x7) 
10865                                               /* r_m at 16 */ == 4 && 
10866                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10867                                               /* index at 24 */ && 
10868                                         (MATCH_w_8_24 >> 3 & 0x7) 
10869                                               /* index at 24 */ < 8)) { 
10870                                         unsigned Eaddr = 
10871                                           2 + addressToPC(MATCH_p);
10872                                         unsigned reg = 
10873                                           (MATCH_w_8_16 >> 3 & 0x7) 
10874                                                 /* reg_opcode at 16 */;
10875                                         nextPC = 5 + MATCH_p; 
10876                                         
10877                                         #line 1081 "machine/pentium/disassembler.m"
10878                                         
10879 
10880                                                 sprintf (str,  "CMPrmow", DIS_REG16, DIS_EADDR16);
10881 
10882                                         
10883 
10884                                         
10885                                         
10886                                         
10887                                       } /*opt-block*//*opt-block+*/
10888                                       else 
10889                                         goto MATCH_label_a426;  /*opt-block+*/
10890                                       
10891                                       break;
10892                                     case 2: 
10893                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10894                                       if ((MATCH_w_8_16 & 0x7) 
10895                                               /* r_m at 16 */ == 4 && 
10896                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10897                                               /* index at 24 */ && 
10898                                         (MATCH_w_8_24 >> 3 & 0x7) 
10899                                               /* index at 24 */ < 8)) 
10900                                         goto MATCH_label_a427;  /*opt-block+*/
10901                                       else 
10902                                         goto MATCH_label_a428;  /*opt-block+*/
10903                                       
10904                                       break;
10905                                     case 3: 
10906                                       goto MATCH_label_a425; break;
10907                                     default: assert(0);
10908                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
10909                                         -- mod at 16 --*/ 
10910                                 
10911                               } /*opt-block*/
10912                               else { 
10913                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
10914                                 
10915                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
10916                                         /* mod at 16 */) {
10917                                     case 0: 
10918                                       
10919                                         switch((MATCH_w_8_16 & 0x7) 
10920                                               /* r_m at 16 */) {
10921                                           case 0: case 1: case 2: case 3: 
10922                                           case 6: case 7: 
10923                                             goto MATCH_label_a421; break;
10924                                           case 4: 
10925                                             MATCH_w_8_24 = 
10926                                               getByte(3 + MATCH_p); 
10927                                             if ((MATCH_w_8_24 & 0x7) 
10928                                                     /* base at 24 */ == 5 && 
10929                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10930                                                     /* index at 24 */ && 
10931                                               (MATCH_w_8_24 >> 3 & 0x7) 
10932                                                     /* index at 24 */ < 8)) 
10933                                               goto MATCH_label_a423;  /*opt-block+*/
10934                                             else 
10935                                               goto MATCH_label_a422;  /*opt-block+*/
10936                                             
10937                                             break;
10938                                           case 5: 
10939                                             goto MATCH_label_a424; break;
10940                                           default: assert(0);
10941                                         } /* (MATCH_w_8_16 & 0x7) 
10942                                               -- r_m at 16 --*/ 
10943                                       break;
10944                                     case 1: 
10945                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10946                                       if ((MATCH_w_8_16 & 0x7) 
10947                                               /* r_m at 16 */ == 4 && 
10948                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10949                                               /* index at 24 */ && 
10950                                         (MATCH_w_8_24 >> 3 & 0x7) 
10951                                               /* index at 24 */ < 8)) { 
10952                                         unsigned Eaddr = 
10953                                           2 + addressToPC(MATCH_p);
10954                                         unsigned reg = 
10955                                           (MATCH_w_8_16 >> 3 & 0x7) 
10956                                                 /* reg_opcode at 16 */;
10957                                         nextPC = 5 + MATCH_p; 
10958                                         
10959                                         #line 1087 "machine/pentium/disassembler.m"
10960                                         
10961 
10962                                                 sprintf (str,  "XORrmow", DIS_REG16, DIS_EADDR16);
10963 
10964                                         
10965 
10966                                         
10967                                         
10968                                         
10969                                       } /*opt-block*//*opt-block+*/
10970                                       else 
10971                                         goto MATCH_label_a422;  /*opt-block+*/
10972                                       
10973                                       break;
10974                                     case 2: 
10975                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
10976                                       if ((MATCH_w_8_16 & 0x7) 
10977                                               /* r_m at 16 */ == 4 && 
10978                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
10979                                               /* index at 24 */ && 
10980                                         (MATCH_w_8_24 >> 3 & 0x7) 
10981                                               /* index at 24 */ < 8)) 
10982                                         goto MATCH_label_a423;  /*opt-block+*/
10983                                       else 
10984                                         goto MATCH_label_a424;  /*opt-block+*/
10985                                       
10986                                       break;
10987                                     case 3: 
10988                                       goto MATCH_label_a421; break;
10989                                     default: assert(0);
10990                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
10991                                         -- mod at 16 --*/ 
10992                                 
10993                               } /*opt-block*/
10994                               break;
10995                             case 5: 
10996                               if ((MATCH_w_8_8 >> 3 & 0x1) 
10997                                       /* page at 8 */ == 1) { 
10998                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
10999                                 { 
11000                                   int /* [~32768..32767] */ i16 = 
11001                                     sign_extend(
11002                                                 (MATCH_w_16_16 & 0xffff) 
11003                                                       /* i16 at 16 */, 16);
11004                                   nextPC = 4 + MATCH_p; 
11005                                   
11006                                   #line 1366 "machine/pentium/disassembler.m"
11007                                   
11008 
11009                                           sprintf (str,  "CMPiAX", DIS_I16);
11010 
11011                                   
11012 
11013                                   
11014                                   
11015                                   
11016                                 }
11017                                 
11018                               } /*opt-block*/
11019                               else { 
11020                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
11021                                 { 
11022                                   int /* [~32768..32767] */ i16 = 
11023                                     sign_extend(
11024                                                 (MATCH_w_16_16 & 0xffff) 
11025                                                       /* i16 at 16 */, 16);
11026                                   nextPC = 4 + MATCH_p; 
11027                                   
11028                                   #line 1369 "machine/pentium/disassembler.m"
11029                                   
11030 
11031                                           sprintf (str,  "XORiAX", DIS_I16);
11032 
11033                                   
11034 
11035                                   
11036                                   
11037                                   
11038                                 }
11039                                 
11040                               } /*opt-block*/
11041                               
11042                               break;
11043                             default: assert(0);
11044                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
11045                         break;
11046                       case 4: 
11047                         if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) { 
11048                           unsigned r32 = (MATCH_w_8_8 & 0x7) /* r32 at 8 */;
11049                           nextPC = 2 + MATCH_p; 
11050                           
11051                           #line 911 "machine/pentium/disassembler.m"
11052                           
11053 
11054                                   sprintf (str,  "DECow", DIS_R32);
11055 
11056                           
11057 
11058                           
11059                           
11060                           
11061                         } /*opt-block*//*opt-block+*/
11062                         else { 
11063                           unsigned r32 = (MATCH_w_8_8 & 0x7) /* r32 at 8 */;
11064                           nextPC = 2 + MATCH_p; 
11065                           
11066                           #line 827 "machine/pentium/disassembler.m"
11067                           
11068 
11069                                   sprintf (str,  "INCow", DIS_R32);
11070 
11071                           
11072 
11073                           
11074                           
11075                           
11076                         } /*opt-block*//*opt-block+*/
11077                         
11078                         break;
11079                       case 5: 
11080                         if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) { 
11081                           unsigned r32 = (MATCH_w_8_8 & 0x7) /* r32 at 8 */;
11082                           nextPC = 2 + MATCH_p; 
11083                           
11084                           #line 579 "machine/pentium/disassembler.m"
11085                           
11086 
11087                                   sprintf (str,  "POPow", DIS_R32);   // Check!
11088 
11089                           
11090 
11091                           
11092                           
11093                           
11094                         } /*opt-block*//*opt-block+*/
11095                         else { 
11096                           unsigned r32 = (MATCH_w_8_8 & 0x7) /* r32 at 8 */;
11097                           nextPC = 2 + MATCH_p; 
11098                           
11099                           #line 540 "machine/pentium/disassembler.m"
11100                           
11101 
11102                                   sprintf (str,  "PUSHow", DIS_R32);  // Check!
11103 
11104                           
11105 
11106                           
11107                           
11108                           
11109                         } /*opt-block*//*opt-block+*/
11110                         
11111                         break;
11112                       case 6: 
11113                         if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) 
11114                           
11115                             switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
11116                               case 0: 
11117                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
11118                                 { 
11119                                   int /* [~32768..32767] */ i16 = 
11120                                     sign_extend(
11121                                                 (MATCH_w_16_16 & 0xffff) 
11122                                                       /* i16 at 16 */, 16);
11123                                   nextPC = 4 + MATCH_p; 
11124                                   
11125                                   #line 528 "machine/pentium/disassembler.m"
11126                                   
11127 
11128                                           sprintf (str,  "PUSH.Ivow", DIS_I16);
11129 
11130                                   
11131 
11132                                   
11133                                   
11134                                   
11135                                 }
11136                                 
11137                                 break;
11138                               case 1: 
11139                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
11140                                 
11141                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
11142                                         /* mod at 16 */) {
11143                                     case 0: 
11144                                       
11145                                         switch((MATCH_w_8_16 & 0x7) 
11146                                               /* r_m at 16 */) {
11147                                           case 0: case 1: case 2: case 3: 
11148                                           case 6: case 7: 
11149                                             MATCH_w_16_24 = 
11150                                               getWord(3 + MATCH_p); 
11151                                             goto MATCH_label_a429; 
11152                                             
11153                                             break;
11154                                           case 4: 
11155                                             MATCH_w_8_24 = 
11156                                               getByte(3 + MATCH_p); 
11157                                             if ((MATCH_w_8_24 & 0x7) 
11158                                                     /* base at 24 */ == 5 && 
11159                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11160                                                     /* index at 24 */ && 
11161                                               (MATCH_w_8_24 >> 3 & 0x7) 
11162                                                     /* index at 24 */ < 8)) { 
11163                                               MATCH_w_16_64 = 
11164                                                 getWord(8 + MATCH_p); 
11165                                               goto MATCH_label_a431; 
11166                                               
11167                                             } /*opt-block*/
11168                                             else { 
11169                                               MATCH_w_16_32 = 
11170                                                 getWord(4 + MATCH_p); 
11171                                               goto MATCH_label_a430; 
11172                                               
11173                                             } /*opt-block*/
11174                                             
11175                                             break;
11176                                           case 5: 
11177                                             MATCH_w_16_56 = 
11178                                               getWord(7 + MATCH_p); 
11179                                             goto MATCH_label_a432; 
11180                                             
11181                                             break;
11182                                           default: assert(0);
11183                                         } /* (MATCH_w_8_16 & 0x7) 
11184                                               -- r_m at 16 --*/ 
11185                                       break;
11186                                     case 1: 
11187                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
11188                                       if ((MATCH_w_8_16 & 0x7) 
11189                                               /* r_m at 16 */ == 4 && 
11190                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11191                                               /* index at 24 */ && 
11192                                         (MATCH_w_8_24 >> 3 & 0x7) 
11193                                               /* index at 24 */ < 8)) { 
11194                                         MATCH_w_16_40 = getWord(5 + MATCH_p); 
11195                                         { 
11196                                           unsigned Eaddr = 
11197                                             2 + addressToPC(MATCH_p);
11198                                           int /* [~32768..32767] */ i16 = 
11199                                             sign_extend(
11200                                                         (MATCH_w_16_40 & 0xffff) 
11201                                                               /* i16 at 40 */, 
11202                                                         16);
11203                                           unsigned reg = 
11204                                             (MATCH_w_8_16 >> 3 & 0x7) 
11205                                                   /* reg_opcode at 16 */;
11206                                           nextPC = 7 + MATCH_p; 
11207                                           
11208                                           #line 860 "machine/pentium/disassembler.m"
11209                                           
11210 
11211                                                   sprintf (str,  "IMUL.Ivw", DIS_REG16, DIS_EADDR16, DIS_I16);
11212 
11213                                           
11214 
11215                                           
11216                                           
11217                                           
11218                                         }
11219                                         
11220                                       } /*opt-block*/
11221                                       else { 
11222                                         MATCH_w_16_32 = getWord(4 + MATCH_p); 
11223                                         goto MATCH_label_a430; 
11224                                         
11225                                       } /*opt-block*/
11226                                       
11227                                       break;
11228                                     case 2: 
11229                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
11230                                       if ((MATCH_w_8_16 & 0x7) 
11231                                               /* r_m at 16 */ == 4 && 
11232                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11233                                               /* index at 24 */ && 
11234                                         (MATCH_w_8_24 >> 3 & 0x7) 
11235                                               /* index at 24 */ < 8)) { 
11236                                         MATCH_w_16_64 = getWord(8 + MATCH_p); 
11237                                         goto MATCH_label_a431; 
11238                                         
11239                                       } /*opt-block*/
11240                                       else { 
11241                                         MATCH_w_16_56 = getWord(7 + MATCH_p); 
11242                                         goto MATCH_label_a432; 
11243                                         
11244                                       } /*opt-block*/
11245                                       
11246                                       break;
11247                                     case 3: 
11248                                       MATCH_w_16_24 = getWord(3 + MATCH_p); 
11249                                       goto MATCH_label_a429; 
11250                                       
11251                                       break;
11252                                     default: assert(0);
11253                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
11254                                         -- mod at 16 --*/ 
11255                                 
11256                                 break;
11257                               case 2: 
11258                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
11259                                 { 
11260                                   int /* [~128..127] */ i8 = 
11261                                     sign_extend(
11262                                                 (MATCH_w_8_16 & 0xff) 
11263                                                       /* i8 at 16 */, 8);
11264                                   nextPC = 3 + MATCH_p; 
11265                                   
11266                                   #line 534 "machine/pentium/disassembler.m"
11267                                   
11268 
11269                                           sprintf (str,  "PUSH.Ixow", DIS_I8);
11270 
11271                                   
11272 
11273                                   
11274                                   
11275                                   
11276                                 }
11277                                 
11278                                 break;
11279                               case 3: 
11280                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
11281                                 
11282                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
11283                                         /* mod at 16 */) {
11284                                     case 0: 
11285                                       
11286                                         switch((MATCH_w_8_16 & 0x7) 
11287                                               /* r_m at 16 */) {
11288                                           case 0: case 1: case 2: case 3: 
11289                                           case 6: case 7: 
11290                                             MATCH_w_8_24 = 
11291                                               getByte(3 + MATCH_p); 
11292                                             goto MATCH_label_a433; 
11293                                             
11294                                             break;
11295                                           case 4: 
11296                                             MATCH_w_8_24 = 
11297                                               getByte(3 + MATCH_p); 
11298                                             if ((MATCH_w_8_24 & 0x7) 
11299                                                     /* base at 24 */ == 5 && 
11300                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11301                                                     /* index at 24 */ && 
11302                                               (MATCH_w_8_24 >> 3 & 0x7) 
11303                                                     /* index at 24 */ < 8)) { 
11304                                               MATCH_w_8_64 = 
11305                                                 getByte(8 + MATCH_p); 
11306                                               goto MATCH_label_a435; 
11307                                               
11308                                             } /*opt-block*/
11309                                             else { 
11310                                               MATCH_w_8_32 = 
11311                                                 getByte(4 + MATCH_p); 
11312                                               goto MATCH_label_a434; 
11313                                               
11314                                             } /*opt-block*/
11315                                             
11316                                             break;
11317                                           case 5: 
11318                                             MATCH_w_8_56 = 
11319                                               getByte(7 + MATCH_p); 
11320                                             goto MATCH_label_a436; 
11321                                             
11322                                             break;
11323                                           default: assert(0);
11324                                         } /* (MATCH_w_8_16 & 0x7) 
11325                                               -- r_m at 16 --*/ 
11326                                       break;
11327                                     case 1: 
11328                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
11329                                       if ((MATCH_w_8_16 & 0x7) 
11330                                               /* r_m at 16 */ == 4 && 
11331                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11332                                               /* index at 24 */ && 
11333                                         (MATCH_w_8_24 >> 3 & 0x7) 
11334                                               /* index at 24 */ < 8)) { 
11335                                         MATCH_w_8_40 = getByte(5 + MATCH_p); 
11336                                         { 
11337                                           unsigned Eaddr = 
11338                                             2 + addressToPC(MATCH_p);
11339                                           int /* [~128..127] */ i8 = 
11340                                             sign_extend(
11341                                                         (MATCH_w_8_40 & 0xff) 
11342                                                               /* i8 at 40 */, 
11343                                                         8);
11344                                           unsigned reg = 
11345                                             (MATCH_w_8_16 >> 3 & 0x7) 
11346                                                   /* reg_opcode at 16 */;
11347                                           nextPC = 6 + MATCH_p; 
11348                                           
11349                                           #line 866 "machine/pentium/disassembler.m"
11350                                           
11351 
11352                                                   sprintf (str,  "IMUL.Ibow", DIS_REG16, DIS_EADDR16, DIS_I8);
11353 
11354                                           
11355 
11356                                           
11357                                           
11358                                           
11359                                         }
11360                                         
11361                                       } /*opt-block*/
11362                                       else { 
11363                                         MATCH_w_8_32 = getByte(4 + MATCH_p); 
11364                                         goto MATCH_label_a434; 
11365                                         
11366                                       } /*opt-block*/
11367                                       
11368                                       break;
11369                                     case 2: 
11370                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
11371                                       if ((MATCH_w_8_16 & 0x7) 
11372                                               /* r_m at 16 */ == 4 && 
11373                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11374                                               /* index at 24 */ && 
11375                                         (MATCH_w_8_24 >> 3 & 0x7) 
11376                                               /* index at 24 */ < 8)) { 
11377                                         MATCH_w_8_64 = getByte(8 + MATCH_p); 
11378                                         goto MATCH_label_a435; 
11379                                         
11380                                       } /*opt-block*/
11381                                       else { 
11382                                         MATCH_w_8_56 = getByte(7 + MATCH_p); 
11383                                         goto MATCH_label_a436; 
11384                                         
11385                                       } /*opt-block*/
11386                                       
11387                                       break;
11388                                     case 3: 
11389                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
11390                                       goto MATCH_label_a433; 
11391                                       
11392                                       break;
11393                                     default: assert(0);
11394                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
11395                                         -- mod at 16 --*/ 
11396                                 
11397                                 break;
11398                               case 4: case 5: case 6: case 7: 
11399                                 goto MATCH_label_a39; break;
11400                               default: assert(0);
11401                             } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/  
11402                         else 
11403                           goto MATCH_label_a39;  /*opt-block+*/
11404                         break;
11405                       case 7: case 14: 
11406                         goto MATCH_label_a39; break;
11407                       case 8: 
11408                         
11409                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
11410                             case 0: case 2: case 4: case 6: 
11411                               goto MATCH_label_a39; break;
11412                             case 1: 
11413                               if ((MATCH_w_8_8 >> 3 & 0x1) 
11414                                       /* page at 8 */ == 1) { 
11415                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
11416                                 
11417                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
11418                                         /* mod at 16 */) {
11419                                     case 0: 
11420                                       
11421                                         switch((MATCH_w_8_16 & 0x7) 
11422                                               /* r_m at 16 */) {
11423                                           case 0: case 1: case 2: case 3: 
11424                                           case 6: case 7: 
11425                                             goto MATCH_label_a469; break;
11426                                           case 4: 
11427                                             MATCH_w_8_24 = 
11428                                               getByte(3 + MATCH_p); 
11429                                             if ((MATCH_w_8_24 & 0x7) 
11430                                                     /* base at 24 */ == 5 && 
11431                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11432                                                     /* index at 24 */ && 
11433                                               (MATCH_w_8_24 >> 3 & 0x7) 
11434                                                     /* index at 24 */ < 8)) 
11435                                               goto MATCH_label_a471;  /*opt-block+*/
11436                                             else 
11437                                               goto MATCH_label_a470;  /*opt-block+*/
11438                                             
11439                                             break;
11440                                           case 5: 
11441                                             goto MATCH_label_a472; break;
11442                                           default: assert(0);
11443                                         } /* (MATCH_w_8_16 & 0x7) 
11444                                               -- r_m at 16 --*/ 
11445                                       break;
11446                                     case 1: 
11447                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
11448                                       if ((MATCH_w_8_16 & 0x7) 
11449                                               /* r_m at 16 */ == 4 && 
11450                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11451                                               /* index at 24 */ && 
11452                                         (MATCH_w_8_24 >> 3 & 0x7) 
11453                                               /* index at 24 */ < 8)) { 
11454                                         unsigned Eaddr = 
11455                                           2 + addressToPC(MATCH_p);
11456                                         unsigned reg = 
11457                                           (MATCH_w_8_16 >> 3 & 0x7) 
11458                                                 /* reg_opcode at 16 */;
11459                                         nextPC = 5 + MATCH_p; 
11460                                         
11461                                         #line 739 "machine/pentium/disassembler.m"
11462                                         
11463 
11464                                                 sprintf (str,  "MOVmrow", DIS_EADDR16, DIS_REG16);
11465 
11466                                         
11467 
11468                                         
11469                                         
11470                                         
11471                                       } /*opt-block*//*opt-block+*/
11472                                       else 
11473                                         goto MATCH_label_a470;  /*opt-block+*/
11474                                       
11475                                       break;
11476                                     case 2: 
11477                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
11478                                       if ((MATCH_w_8_16 & 0x7) 
11479                                               /* r_m at 16 */ == 4 && 
11480                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11481                                               /* index at 24 */ && 
11482                                         (MATCH_w_8_24 >> 3 & 0x7) 
11483                                               /* index at 24 */ < 8)) 
11484                                         goto MATCH_label_a471;  /*opt-block+*/
11485                                       else 
11486                                         goto MATCH_label_a472;  /*opt-block+*/
11487                                       
11488                                       break;
11489                                     case 3: 
11490                                       goto MATCH_label_a469; break;
11491                                     default: assert(0);
11492                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
11493                                         -- mod at 16 --*/ 
11494                                 
11495                               } /*opt-block*/
11496                               else { 
11497                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
11498                                 
11499                                   switch((MATCH_w_8_16 >> 3 & 0x7) 
11500                                         /* reg_opcode at 16 */) {
11501                                     case 0: 
11502                                       
11503                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
11504                                               /* mod at 16 */) {
11505                                           case 0: 
11506                                             
11507                                               switch((MATCH_w_8_16 & 0x7) 
11508                                                     /* r_m at 16 */) {
11509                                                 case 0: case 1: case 2: 
11510                                                 case 3: case 6: case 7: 
11511                                                   MATCH_w_16_24 = 
11512                                                     getWord(3 + MATCH_p); 
11513                                                   goto MATCH_label_a437; 
11514                                                   
11515                                                   break;
11516                                                 case 4: 
11517                                                   MATCH_w_8_24 = 
11518                                                     getByte(3 + MATCH_p); 
11519                                                   if ((MATCH_w_8_24 & 0x7) 
11520                                                           /* base at 24 */ == 5 && 
11521                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11522                                                           /* index at 24 */ && 
11523                                                     (MATCH_w_8_24 >> 3 & 0x7) 
11524                                                           /* index at 24 */ < 8)) { 
11525                                                     MATCH_w_16_64 = 
11526                                                       getWord(8 + MATCH_p); 
11527                                                     goto MATCH_label_a439; 
11528                                                     
11529                                                   } /*opt-block*/
11530                                                   else { 
11531                                                     MATCH_w_16_32 = 
11532                                                       getWord(4 + MATCH_p); 
11533                                                     goto MATCH_label_a438; 
11534                                                     
11535                                                   } /*opt-block*/
11536                                                   
11537                                                   break;
11538                                                 case 5: 
11539                                                   MATCH_w_16_56 = 
11540                                                     getWord(7 + MATCH_p); 
11541                                                   goto MATCH_label_a440; 
11542                                                   
11543                                                   break;
11544                                                 default: assert(0);
11545                                               } /* (MATCH_w_8_16 & 0x7) 
11546                                                     -- r_m at 16 --*/ 
11547                                             break;
11548                                           case 1: 
11549                                             MATCH_w_8_24 = 
11550                                               getByte(3 + MATCH_p); 
11551                                             if ((MATCH_w_8_16 & 0x7) 
11552                                                     /* r_m at 16 */ == 4 && 
11553                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11554                                                     /* index at 24 */ && 
11555                                               (MATCH_w_8_24 >> 3 & 0x7) 
11556                                                     /* index at 24 */ < 8)) { 
11557                                               MATCH_w_16_40 = 
11558                                                 getWord(5 + MATCH_p); 
11559                                               { 
11560                                                 unsigned Eaddr = 
11561                                                   2 + addressToPC(MATCH_p);
11562                                                 int /* [~32768..32767] */ i16 = 
11563                                                   sign_extend(
11564                                                               (MATCH_w_16_40 & 0xffff) 
11565                                                                     /* i16 at 40 */, 
11566                                                               16);
11567                                                 nextPC = 7 + MATCH_p; 
11568                                                 
11569                                                 #line 1315 "machine/pentium/disassembler.m"
11570                                                 
11571 
11572                                                         sprintf (str,  "ADDiw", DIS_EADDR16, DIS_I16);
11573 
11574                                                 
11575 
11576                                                 
11577                                                 
11578                                                 
11579                                               }
11580                                               
11581                                             } /*opt-block*/
11582                                             else { 
11583                                               MATCH_w_16_32 = 
11584                                                 getWord(4 + MATCH_p); 
11585                                               goto MATCH_label_a438; 
11586                                               
11587                                             } /*opt-block*/
11588                                             
11589                                             break;
11590                                           case 2: 
11591                                             MATCH_w_8_24 = 
11592                                               getByte(3 + MATCH_p); 
11593                                             if ((MATCH_w_8_16 & 0x7) 
11594                                                     /* r_m at 16 */ == 4 && 
11595                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11596                                                     /* index at 24 */ && 
11597                                               (MATCH_w_8_24 >> 3 & 0x7) 
11598                                                     /* index at 24 */ < 8)) { 
11599                                               MATCH_w_16_64 = 
11600                                                 getWord(8 + MATCH_p); 
11601                                               goto MATCH_label_a439; 
11602                                               
11603                                             } /*opt-block*/
11604                                             else { 
11605                                               MATCH_w_16_56 = 
11606                                                 getWord(7 + MATCH_p); 
11607                                               goto MATCH_label_a440; 
11608                                               
11609                                             } /*opt-block*/
11610                                             
11611                                             break;
11612                                           case 3: 
11613                                             MATCH_w_16_24 = 
11614                                               getWord(3 + MATCH_p); 
11615                                             goto MATCH_label_a437; 
11616                                             
11617                                             break;
11618                                           default: assert(0);
11619                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
11620                                               -- mod at 16 --*/ 
11621                                       break;
11622                                     case 1: 
11623                                       
11624                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
11625                                               /* mod at 16 */) {
11626                                           case 0: 
11627                                             
11628                                               switch((MATCH_w_8_16 & 0x7) 
11629                                                     /* r_m at 16 */) {
11630                                                 case 0: case 1: case 2: 
11631                                                 case 3: case 6: case 7: 
11632                                                   MATCH_w_16_24 = 
11633                                                     getWord(3 + MATCH_p); 
11634                                                   goto MATCH_label_a441; 
11635                                                   
11636                                                   break;
11637                                                 case 4: 
11638                                                   MATCH_w_8_24 = 
11639                                                     getByte(3 + MATCH_p); 
11640                                                   if ((MATCH_w_8_24 & 0x7) 
11641                                                           /* base at 24 */ == 5 && 
11642                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11643                                                           /* index at 24 */ && 
11644                                                     (MATCH_w_8_24 >> 3 & 0x7) 
11645                                                           /* index at 24 */ < 8)) { 
11646                                                     MATCH_w_16_64 = 
11647                                                       getWord(8 + MATCH_p); 
11648                                                     goto MATCH_label_a443; 
11649                                                     
11650                                                   } /*opt-block*/
11651                                                   else { 
11652                                                     MATCH_w_16_32 = 
11653                                                       getWord(4 + MATCH_p); 
11654                                                     goto MATCH_label_a442; 
11655                                                     
11656                                                   } /*opt-block*/
11657                                                   
11658                                                   break;
11659                                                 case 5: 
11660                                                   MATCH_w_16_56 = 
11661                                                     getWord(7 + MATCH_p); 
11662                                                   goto MATCH_label_a444; 
11663                                                   
11664                                                   break;
11665                                                 default: assert(0);
11666                                               } /* (MATCH_w_8_16 & 0x7) 
11667                                                     -- r_m at 16 --*/ 
11668                                             break;
11669                                           case 1: 
11670                                             MATCH_w_8_24 = 
11671                                               getByte(3 + MATCH_p); 
11672                                             if ((MATCH_w_8_16 & 0x7) 
11673                                                     /* r_m at 16 */ == 4 && 
11674                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11675                                                     /* index at 24 */ && 
11676                                               (MATCH_w_8_24 >> 3 & 0x7) 
11677                                                     /* index at 24 */ < 8)) { 
11678                                               MATCH_w_16_40 = 
11679                                                 getWord(5 + MATCH_p); 
11680                                               { 
11681                                                 unsigned Eaddr = 
11682                                                   2 + addressToPC(MATCH_p);
11683                                                 int /* [~32768..32767] */ i16 = 
11684                                                   sign_extend(
11685                                                               (MATCH_w_16_40 & 0xffff) 
11686                                                                     /* i16 at 40 */, 
11687                                                               16);
11688                                                 nextPC = 7 + MATCH_p; 
11689                                                 
11690                                                 #line 1312 "machine/pentium/disassembler.m"
11691                                                 
11692 
11693                                                         sprintf (str,  "ORiw", DIS_EADDR16, DIS_I16);
11694 
11695                                                 
11696 
11697                                                 
11698                                                 
11699                                                 
11700                                               }
11701                                               
11702                                             } /*opt-block*/
11703                                             else { 
11704                                               MATCH_w_16_32 = 
11705                                                 getWord(4 + MATCH_p); 
11706                                               goto MATCH_label_a442; 
11707                                               
11708                                             } /*opt-block*/
11709                                             
11710                                             break;
11711                                           case 2: 
11712                                             MATCH_w_8_24 = 
11713                                               getByte(3 + MATCH_p); 
11714                                             if ((MATCH_w_8_16 & 0x7) 
11715                                                     /* r_m at 16 */ == 4 && 
11716                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11717                                                     /* index at 24 */ && 
11718                                               (MATCH_w_8_24 >> 3 & 0x7) 
11719                                                     /* index at 24 */ < 8)) { 
11720                                               MATCH_w_16_64 = 
11721                                                 getWord(8 + MATCH_p); 
11722                                               goto MATCH_label_a443; 
11723                                               
11724                                             } /*opt-block*/
11725                                             else { 
11726                                               MATCH_w_16_56 = 
11727                                                 getWord(7 + MATCH_p); 
11728                                               goto MATCH_label_a444; 
11729                                               
11730                                             } /*opt-block*/
11731                                             
11732                                             break;
11733                                           case 3: 
11734                                             MATCH_w_16_24 = 
11735                                               getWord(3 + MATCH_p); 
11736                                             goto MATCH_label_a441; 
11737                                             
11738                                             break;
11739                                           default: assert(0);
11740                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
11741                                               -- mod at 16 --*/ 
11742                                       break;
11743                                     case 2: 
11744                                       
11745                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
11746                                               /* mod at 16 */) {
11747                                           case 0: 
11748                                             
11749                                               switch((MATCH_w_8_16 & 0x7) 
11750                                                     /* r_m at 16 */) {
11751                                                 case 0: case 1: case 2: 
11752                                                 case 3: case 6: case 7: 
11753                                                   MATCH_w_16_24 = 
11754                                                     getWord(3 + MATCH_p); 
11755                                                   goto MATCH_label_a445; 
11756                                                   
11757                                                   break;
11758                                                 case 4: 
11759                                                   MATCH_w_8_24 = 
11760                                                     getByte(3 + MATCH_p); 
11761                                                   if ((MATCH_w_8_24 & 0x7) 
11762                                                           /* base at 24 */ == 5 && 
11763                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11764                                                           /* index at 24 */ && 
11765                                                     (MATCH_w_8_24 >> 3 & 0x7) 
11766                                                           /* index at 24 */ < 8)) { 
11767                                                     MATCH_w_16_64 = 
11768                                                       getWord(8 + MATCH_p); 
11769                                                     goto MATCH_label_a447; 
11770                                                     
11771                                                   } /*opt-block*/
11772                                                   else { 
11773                                                     MATCH_w_16_32 = 
11774                                                       getWord(4 + MATCH_p); 
11775                                                     goto MATCH_label_a446; 
11776                                                     
11777                                                   } /*opt-block*/
11778                                                   
11779                                                   break;
11780                                                 case 5: 
11781                                                   MATCH_w_16_56 = 
11782                                                     getWord(7 + MATCH_p); 
11783                                                   goto MATCH_label_a448; 
11784                                                   
11785                                                   break;
11786                                                 default: assert(0);
11787                                               } /* (MATCH_w_8_16 & 0x7) 
11788                                                     -- r_m at 16 --*/ 
11789                                             break;
11790                                           case 1: 
11791                                             MATCH_w_8_24 = 
11792                                               getByte(3 + MATCH_p); 
11793                                             if ((MATCH_w_8_16 & 0x7) 
11794                                                     /* r_m at 16 */ == 4 && 
11795                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11796                                                     /* index at 24 */ && 
11797                                               (MATCH_w_8_24 >> 3 & 0x7) 
11798                                                     /* index at 24 */ < 8)) { 
11799                                               MATCH_w_16_40 = 
11800                                                 getWord(5 + MATCH_p); 
11801                                               { 
11802                                                 unsigned Eaddr = 
11803                                                   2 + addressToPC(MATCH_p);
11804                                                 int /* [~32768..32767] */ i16 = 
11805                                                   sign_extend(
11806                                                               (MATCH_w_16_40 & 0xffff) 
11807                                                                     /* i16 at 40 */, 
11808                                                               16);
11809                                                 nextPC = 7 + MATCH_p; 
11810                                                 
11811                                                 #line 1309 "machine/pentium/disassembler.m"
11812                                                 
11813 
11814                                                         sprintf (str,  "ADCiw", DIS_EADDR16, DIS_I16);
11815 
11816                                                 
11817 
11818                                                 
11819                                                 
11820                                                 
11821                                               }
11822                                               
11823                                             } /*opt-block*/
11824                                             else { 
11825                                               MATCH_w_16_32 = 
11826                                                 getWord(4 + MATCH_p); 
11827                                               goto MATCH_label_a446; 
11828                                               
11829                                             } /*opt-block*/
11830                                             
11831                                             break;
11832                                           case 2: 
11833                                             MATCH_w_8_24 = 
11834                                               getByte(3 + MATCH_p); 
11835                                             if ((MATCH_w_8_16 & 0x7) 
11836                                                     /* r_m at 16 */ == 4 && 
11837                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11838                                                     /* index at 24 */ && 
11839                                               (MATCH_w_8_24 >> 3 & 0x7) 
11840                                                     /* index at 24 */ < 8)) { 
11841                                               MATCH_w_16_64 = 
11842                                                 getWord(8 + MATCH_p); 
11843                                               goto MATCH_label_a447; 
11844                                               
11845                                             } /*opt-block*/
11846                                             else { 
11847                                               MATCH_w_16_56 = 
11848                                                 getWord(7 + MATCH_p); 
11849                                               goto MATCH_label_a448; 
11850                                               
11851                                             } /*opt-block*/
11852                                             
11853                                             break;
11854                                           case 3: 
11855                                             MATCH_w_16_24 = 
11856                                               getWord(3 + MATCH_p); 
11857                                             goto MATCH_label_a445; 
11858                                             
11859                                             break;
11860                                           default: assert(0);
11861                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
11862                                               -- mod at 16 --*/ 
11863                                       break;
11864                                     case 3: 
11865                                       
11866                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
11867                                               /* mod at 16 */) {
11868                                           case 0: 
11869                                             
11870                                               switch((MATCH_w_8_16 & 0x7) 
11871                                                     /* r_m at 16 */) {
11872                                                 case 0: case 1: case 2: 
11873                                                 case 3: case 6: case 7: 
11874                                                   MATCH_w_16_24 = 
11875                                                     getWord(3 + MATCH_p); 
11876                                                   goto MATCH_label_a449; 
11877                                                   
11878                                                   break;
11879                                                 case 4: 
11880                                                   MATCH_w_8_24 = 
11881                                                     getByte(3 + MATCH_p); 
11882                                                   if ((MATCH_w_8_24 & 0x7) 
11883                                                           /* base at 24 */ == 5 && 
11884                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11885                                                           /* index at 24 */ && 
11886                                                     (MATCH_w_8_24 >> 3 & 0x7) 
11887                                                           /* index at 24 */ < 8)) { 
11888                                                     MATCH_w_16_64 = 
11889                                                       getWord(8 + MATCH_p); 
11890                                                     goto MATCH_label_a451; 
11891                                                     
11892                                                   } /*opt-block*/
11893                                                   else { 
11894                                                     MATCH_w_16_32 = 
11895                                                       getWord(4 + MATCH_p); 
11896                                                     goto MATCH_label_a450; 
11897                                                     
11898                                                   } /*opt-block*/
11899                                                   
11900                                                   break;
11901                                                 case 5: 
11902                                                   MATCH_w_16_56 = 
11903                                                     getWord(7 + MATCH_p); 
11904                                                   goto MATCH_label_a452; 
11905                                                   
11906                                                   break;
11907                                                 default: assert(0);
11908                                               } /* (MATCH_w_8_16 & 0x7) 
11909                                                     -- r_m at 16 --*/ 
11910                                             break;
11911                                           case 1: 
11912                                             MATCH_w_8_24 = 
11913                                               getByte(3 + MATCH_p); 
11914                                             if ((MATCH_w_8_16 & 0x7) 
11915                                                     /* r_m at 16 */ == 4 && 
11916                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11917                                                     /* index at 24 */ && 
11918                                               (MATCH_w_8_24 >> 3 & 0x7) 
11919                                                     /* index at 24 */ < 8)) { 
11920                                               MATCH_w_16_40 = 
11921                                                 getWord(5 + MATCH_p); 
11922                                               { 
11923                                                 unsigned Eaddr = 
11924                                                   2 + addressToPC(MATCH_p);
11925                                                 int /* [~32768..32767] */ i16 = 
11926                                                   sign_extend(
11927                                                               (MATCH_w_16_40 & 0xffff) 
11928                                                                     /* i16 at 40 */, 
11929                                                               16);
11930                                                 nextPC = 7 + MATCH_p; 
11931                                                 
11932                                                 #line 1306 "machine/pentium/disassembler.m"
11933                                                 
11934 
11935                                                         sprintf (str,  "SBBiw", DIS_EADDR16, DIS_I16);
11936 
11937                                                 
11938 
11939                                                 
11940                                                 
11941                                                 
11942                                               }
11943                                               
11944                                             } /*opt-block*/
11945                                             else { 
11946                                               MATCH_w_16_32 = 
11947                                                 getWord(4 + MATCH_p); 
11948                                               goto MATCH_label_a450; 
11949                                               
11950                                             } /*opt-block*/
11951                                             
11952                                             break;
11953                                           case 2: 
11954                                             MATCH_w_8_24 = 
11955                                               getByte(3 + MATCH_p); 
11956                                             if ((MATCH_w_8_16 & 0x7) 
11957                                                     /* r_m at 16 */ == 4 && 
11958                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
11959                                                     /* index at 24 */ && 
11960                                               (MATCH_w_8_24 >> 3 & 0x7) 
11961                                                     /* index at 24 */ < 8)) { 
11962                                               MATCH_w_16_64 = 
11963                                                 getWord(8 + MATCH_p); 
11964                                               goto MATCH_label_a451; 
11965                                               
11966                                             } /*opt-block*/
11967                                             else { 
11968                                               MATCH_w_16_56 = 
11969                                                 getWord(7 + MATCH_p); 
11970                                               goto MATCH_label_a452; 
11971                                               
11972                                             } /*opt-block*/
11973                                             
11974                                             break;
11975                                           case 3: 
11976                                             MATCH_w_16_24 = 
11977                                               getWord(3 + MATCH_p); 
11978                                             goto MATCH_label_a449; 
11979                                             
11980                                             break;
11981                                           default: assert(0);
11982                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
11983                                               -- mod at 16 --*/ 
11984                                       break;
11985                                     case 4: 
11986                                       
11987                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
11988                                               /* mod at 16 */) {
11989                                           case 0: 
11990                                             
11991                                               switch((MATCH_w_8_16 & 0x7) 
11992                                                     /* r_m at 16 */) {
11993                                                 case 0: case 1: case 2: 
11994                                                 case 3: case 6: case 7: 
11995                                                   MATCH_w_16_24 = 
11996                                                     getWord(3 + MATCH_p); 
11997                                                   goto MATCH_label_a453; 
11998                                                   
11999                                                   break;
12000                                                 case 4: 
12001                                                   MATCH_w_8_24 = 
12002                                                     getByte(3 + MATCH_p); 
12003                                                   if ((MATCH_w_8_24 & 0x7) 
12004                                                           /* base at 24 */ == 5 && 
12005                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12006                                                           /* index at 24 */ && 
12007                                                     (MATCH_w_8_24 >> 3 & 0x7) 
12008                                                           /* index at 24 */ < 8)) { 
12009                                                     MATCH_w_16_64 = 
12010                                                       getWord(8 + MATCH_p); 
12011                                                     goto MATCH_label_a455; 
12012                                                     
12013                                                   } /*opt-block*/
12014                                                   else { 
12015                                                     MATCH_w_16_32 = 
12016                                                       getWord(4 + MATCH_p); 
12017                                                     goto MATCH_label_a454; 
12018                                                     
12019                                                   } /*opt-block*/
12020                                                   
12021                                                   break;
12022                                                 case 5: 
12023                                                   MATCH_w_16_56 = 
12024                                                     getWord(7 + MATCH_p); 
12025                                                   goto MATCH_label_a456; 
12026                                                   
12027                                                   break;
12028                                                 default: assert(0);
12029                                               } /* (MATCH_w_8_16 & 0x7) 
12030                                                     -- r_m at 16 --*/ 
12031                                             break;
12032                                           case 1: 
12033                                             MATCH_w_8_24 = 
12034                                               getByte(3 + MATCH_p); 
12035                                             if ((MATCH_w_8_16 & 0x7) 
12036                                                     /* r_m at 16 */ == 4 && 
12037                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12038                                                     /* index at 24 */ && 
12039                                               (MATCH_w_8_24 >> 3 & 0x7) 
12040                                                     /* index at 24 */ < 8)) { 
12041                                               MATCH_w_16_40 = 
12042                                                 getWord(5 + MATCH_p); 
12043                                               { 
12044                                                 unsigned Eaddr = 
12045                                                   2 + addressToPC(MATCH_p);
12046                                                 int /* [~32768..32767] */ i16 = 
12047                                                   sign_extend(
12048                                                               (MATCH_w_16_40 & 0xffff) 
12049                                                                     /* i16 at 40 */, 
12050                                                               16);
12051                                                 nextPC = 7 + MATCH_p; 
12052                                                 
12053                                                 #line 1303 "machine/pentium/disassembler.m"
12054                                                 
12055 
12056                                                         sprintf (str,  "ANDiw", DIS_EADDR16, DIS_I16);
12057 
12058                                                 
12059 
12060                                                 
12061                                                 
12062                                                 
12063                                               }
12064                                               
12065                                             } /*opt-block*/
12066                                             else { 
12067                                               MATCH_w_16_32 = 
12068                                                 getWord(4 + MATCH_p); 
12069                                               goto MATCH_label_a454; 
12070                                               
12071                                             } /*opt-block*/
12072                                             
12073                                             break;
12074                                           case 2: 
12075                                             MATCH_w_8_24 = 
12076                                               getByte(3 + MATCH_p); 
12077                                             if ((MATCH_w_8_16 & 0x7) 
12078                                                     /* r_m at 16 */ == 4 && 
12079                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12080                                                     /* index at 24 */ && 
12081                                               (MATCH_w_8_24 >> 3 & 0x7) 
12082                                                     /* index at 24 */ < 8)) { 
12083                                               MATCH_w_16_64 = 
12084                                                 getWord(8 + MATCH_p); 
12085                                               goto MATCH_label_a455; 
12086                                               
12087                                             } /*opt-block*/
12088                                             else { 
12089                                               MATCH_w_16_56 = 
12090                                                 getWord(7 + MATCH_p); 
12091                                               goto MATCH_label_a456; 
12092                                               
12093                                             } /*opt-block*/
12094                                             
12095                                             break;
12096                                           case 3: 
12097                                             MATCH_w_16_24 = 
12098                                               getWord(3 + MATCH_p); 
12099                                             goto MATCH_label_a453; 
12100                                             
12101                                             break;
12102                                           default: assert(0);
12103                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
12104                                               -- mod at 16 --*/ 
12105                                       break;
12106                                     case 5: 
12107                                       
12108                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
12109                                               /* mod at 16 */) {
12110                                           case 0: 
12111                                             
12112                                               switch((MATCH_w_8_16 & 0x7) 
12113                                                     /* r_m at 16 */) {
12114                                                 case 0: case 1: case 2: 
12115                                                 case 3: case 6: case 7: 
12116                                                   MATCH_w_16_24 = 
12117                                                     getWord(3 + MATCH_p); 
12118                                                   goto MATCH_label_a457; 
12119                                                   
12120                                                   break;
12121                                                 case 4: 
12122                                                   MATCH_w_8_24 = 
12123                                                     getByte(3 + MATCH_p); 
12124                                                   if ((MATCH_w_8_24 & 0x7) 
12125                                                           /* base at 24 */ == 5 && 
12126                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12127                                                           /* index at 24 */ && 
12128                                                     (MATCH_w_8_24 >> 3 & 0x7) 
12129                                                           /* index at 24 */ < 8)) { 
12130                                                     MATCH_w_16_64 = 
12131                                                       getWord(8 + MATCH_p); 
12132                                                     goto MATCH_label_a459; 
12133                                                     
12134                                                   } /*opt-block*/
12135                                                   else { 
12136                                                     MATCH_w_16_32 = 
12137                                                       getWord(4 + MATCH_p); 
12138                                                     goto MATCH_label_a458; 
12139                                                     
12140                                                   } /*opt-block*/
12141                                                   
12142                                                   break;
12143                                                 case 5: 
12144                                                   MATCH_w_16_56 = 
12145                                                     getWord(7 + MATCH_p); 
12146                                                   goto MATCH_label_a460; 
12147                                                   
12148                                                   break;
12149                                                 default: assert(0);
12150                                               } /* (MATCH_w_8_16 & 0x7) 
12151                                                     -- r_m at 16 --*/ 
12152                                             break;
12153                                           case 1: 
12154                                             MATCH_w_8_24 = 
12155                                               getByte(3 + MATCH_p); 
12156                                             if ((MATCH_w_8_16 & 0x7) 
12157                                                     /* r_m at 16 */ == 4 && 
12158                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12159                                                     /* index at 24 */ && 
12160                                               (MATCH_w_8_24 >> 3 & 0x7) 
12161                                                     /* index at 24 */ < 8)) { 
12162                                               MATCH_w_16_40 = 
12163                                                 getWord(5 + MATCH_p); 
12164                                               { 
12165                                                 unsigned Eaddr = 
12166                                                   2 + addressToPC(MATCH_p);
12167                                                 int /* [~32768..32767] */ i16 = 
12168                                                   sign_extend(
12169                                                               (MATCH_w_16_40 & 0xffff) 
12170                                                                     /* i16 at 40 */, 
12171                                                               16);
12172                                                 nextPC = 7 + MATCH_p; 
12173                                                 
12174                                                 #line 1300 "machine/pentium/disassembler.m"
12175                                                 
12176 
12177                                                         sprintf (str,  "SUBiw", DIS_EADDR16, DIS_I16);
12178 
12179                                                 
12180 
12181                                                 
12182                                                 
12183                                                 
12184                                               }
12185                                               
12186                                             } /*opt-block*/
12187                                             else { 
12188                                               MATCH_w_16_32 = 
12189                                                 getWord(4 + MATCH_p); 
12190                                               goto MATCH_label_a458; 
12191                                               
12192                                             } /*opt-block*/
12193                                             
12194                                             break;
12195                                           case 2: 
12196                                             MATCH_w_8_24 = 
12197                                               getByte(3 + MATCH_p); 
12198                                             if ((MATCH_w_8_16 & 0x7) 
12199                                                     /* r_m at 16 */ == 4 && 
12200                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12201                                                     /* index at 24 */ && 
12202                                               (MATCH_w_8_24 >> 3 & 0x7) 
12203                                                     /* index at 24 */ < 8)) { 
12204                                               MATCH_w_16_64 = 
12205                                                 getWord(8 + MATCH_p); 
12206                                               goto MATCH_label_a459; 
12207                                               
12208                                             } /*opt-block*/
12209                                             else { 
12210                                               MATCH_w_16_56 = 
12211                                                 getWord(7 + MATCH_p); 
12212                                               goto MATCH_label_a460; 
12213                                               
12214                                             } /*opt-block*/
12215                                             
12216                                             break;
12217                                           case 3: 
12218                                             MATCH_w_16_24 = 
12219                                               getWord(3 + MATCH_p); 
12220                                             goto MATCH_label_a457; 
12221                                             
12222                                             break;
12223                                           default: assert(0);
12224                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
12225                                               -- mod at 16 --*/ 
12226                                       break;
12227                                     case 6: 
12228                                       
12229                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
12230                                               /* mod at 16 */) {
12231                                           case 0: 
12232                                             
12233                                               switch((MATCH_w_8_16 & 0x7) 
12234                                                     /* r_m at 16 */) {
12235                                                 case 0: case 1: case 2: 
12236                                                 case 3: case 6: case 7: 
12237                                                   MATCH_w_16_24 = 
12238                                                     getWord(3 + MATCH_p); 
12239                                                   goto MATCH_label_a461; 
12240                                                   
12241                                                   break;
12242                                                 case 4: 
12243                                                   MATCH_w_8_24 = 
12244                                                     getByte(3 + MATCH_p); 
12245                                                   if ((MATCH_w_8_24 & 0x7) 
12246                                                           /* base at 24 */ == 5 && 
12247                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12248                                                           /* index at 24 */ && 
12249                                                     (MATCH_w_8_24 >> 3 & 0x7) 
12250                                                           /* index at 24 */ < 8)) { 
12251                                                     MATCH_w_16_64 = 
12252                                                       getWord(8 + MATCH_p); 
12253                                                     goto MATCH_label_a463; 
12254                                                     
12255                                                   } /*opt-block*/
12256                                                   else { 
12257                                                     MATCH_w_16_32 = 
12258                                                       getWord(4 + MATCH_p); 
12259                                                     goto MATCH_label_a462; 
12260                                                     
12261                                                   } /*opt-block*/
12262                                                   
12263                                                   break;
12264                                                 case 5: 
12265                                                   MATCH_w_16_56 = 
12266                                                     getWord(7 + MATCH_p); 
12267                                                   goto MATCH_label_a464; 
12268                                                   
12269                                                   break;
12270                                                 default: assert(0);
12271                                               } /* (MATCH_w_8_16 & 0x7) 
12272                                                     -- r_m at 16 --*/ 
12273                                             break;
12274                                           case 1: 
12275                                             MATCH_w_8_24 = 
12276                                               getByte(3 + MATCH_p); 
12277                                             if ((MATCH_w_8_16 & 0x7) 
12278                                                     /* r_m at 16 */ == 4 && 
12279                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12280                                                     /* index at 24 */ && 
12281                                               (MATCH_w_8_24 >> 3 & 0x7) 
12282                                                     /* index at 24 */ < 8)) { 
12283                                               MATCH_w_16_40 = 
12284                                                 getWord(5 + MATCH_p); 
12285                                               { 
12286                                                 unsigned Eaddr = 
12287                                                   2 + addressToPC(MATCH_p);
12288                                                 int /* [~32768..32767] */ i16 = 
12289                                                   sign_extend(
12290                                                               (MATCH_w_16_40 & 0xffff) 
12291                                                                     /* i16 at 40 */, 
12292                                                               16);
12293                                                 nextPC = 7 + MATCH_p; 
12294                                                 
12295                                                 #line 1297 "machine/pentium/disassembler.m"
12296                                                 
12297 
12298                                                         sprintf (str,  "XORiw", DIS_EADDR16, DIS_I16);
12299 
12300                                                 
12301 
12302                                                 
12303                                                 
12304                                                 
12305                                               }
12306                                               
12307                                             } /*opt-block*/
12308                                             else { 
12309                                               MATCH_w_16_32 = 
12310                                                 getWord(4 + MATCH_p); 
12311                                               goto MATCH_label_a462; 
12312                                               
12313                                             } /*opt-block*/
12314                                             
12315                                             break;
12316                                           case 2: 
12317                                             MATCH_w_8_24 = 
12318                                               getByte(3 + MATCH_p); 
12319                                             if ((MATCH_w_8_16 & 0x7) 
12320                                                     /* r_m at 16 */ == 4 && 
12321                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12322                                                     /* index at 24 */ && 
12323                                               (MATCH_w_8_24 >> 3 & 0x7) 
12324                                                     /* index at 24 */ < 8)) { 
12325                                               MATCH_w_16_64 = 
12326                                                 getWord(8 + MATCH_p); 
12327                                               goto MATCH_label_a463; 
12328                                               
12329                                             } /*opt-block*/
12330                                             else { 
12331                                               MATCH_w_16_56 = 
12332                                                 getWord(7 + MATCH_p); 
12333                                               goto MATCH_label_a464; 
12334                                               
12335                                             } /*opt-block*/
12336                                             
12337                                             break;
12338                                           case 3: 
12339                                             MATCH_w_16_24 = 
12340                                               getWord(3 + MATCH_p); 
12341                                             goto MATCH_label_a461; 
12342                                             
12343                                             break;
12344                                           default: assert(0);
12345                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
12346                                               -- mod at 16 --*/ 
12347                                       break;
12348                                     case 7: 
12349                                       
12350                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
12351                                               /* mod at 16 */) {
12352                                           case 0: 
12353                                             
12354                                               switch((MATCH_w_8_16 & 0x7) 
12355                                                     /* r_m at 16 */) {
12356                                                 case 0: case 1: case 2: 
12357                                                 case 3: case 6: case 7: 
12358                                                   MATCH_w_16_24 = 
12359                                                     getWord(3 + MATCH_p); 
12360                                                   goto MATCH_label_a465; 
12361                                                   
12362                                                   break;
12363                                                 case 4: 
12364                                                   MATCH_w_8_24 = 
12365                                                     getByte(3 + MATCH_p); 
12366                                                   if ((MATCH_w_8_24 & 0x7) 
12367                                                           /* base at 24 */ == 5 && 
12368                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12369                                                           /* index at 24 */ && 
12370                                                     (MATCH_w_8_24 >> 3 & 0x7) 
12371                                                           /* index at 24 */ < 8)) { 
12372                                                     MATCH_w_16_64 = 
12373                                                       getWord(8 + MATCH_p); 
12374                                                     goto MATCH_label_a467; 
12375                                                     
12376                                                   } /*opt-block*/
12377                                                   else { 
12378                                                     MATCH_w_16_32 = 
12379                                                       getWord(4 + MATCH_p); 
12380                                                     goto MATCH_label_a466; 
12381                                                     
12382                                                   } /*opt-block*/
12383                                                   
12384                                                   break;
12385                                                 case 5: 
12386                                                   MATCH_w_16_56 = 
12387                                                     getWord(7 + MATCH_p); 
12388                                                   goto MATCH_label_a468; 
12389                                                   
12390                                                   break;
12391                                                 default: assert(0);
12392                                               } /* (MATCH_w_8_16 & 0x7) 
12393                                                     -- r_m at 16 --*/ 
12394                                             break;
12395                                           case 1: 
12396                                             MATCH_w_8_24 = 
12397                                               getByte(3 + MATCH_p); 
12398                                             if ((MATCH_w_8_16 & 0x7) 
12399                                                     /* r_m at 16 */ == 4 && 
12400                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12401                                                     /* index at 24 */ && 
12402                                               (MATCH_w_8_24 >> 3 & 0x7) 
12403                                                     /* index at 24 */ < 8)) { 
12404                                               MATCH_w_16_40 = 
12405                                                 getWord(5 + MATCH_p); 
12406                                               { 
12407                                                 unsigned Eaddr = 
12408                                                   2 + addressToPC(MATCH_p);
12409                                                 int /* [~32768..32767] */ i16 = 
12410                                                   sign_extend(
12411                                                               (MATCH_w_16_40 & 0xffff) 
12412                                                                     /* i16 at 40 */, 
12413                                                               16);
12414                                                 nextPC = 7 + MATCH_p; 
12415                                                 
12416                                                 #line 1294 "machine/pentium/disassembler.m"
12417                                                 
12418 
12419                                                         sprintf (str,  "CMPiw", DIS_EADDR16, DIS_I16);
12420 
12421                                                 
12422 
12423                                                 
12424                                                 
12425                                                 
12426                                               }
12427                                               
12428                                             } /*opt-block*/
12429                                             else { 
12430                                               MATCH_w_16_32 = 
12431                                                 getWord(4 + MATCH_p); 
12432                                               goto MATCH_label_a466; 
12433                                               
12434                                             } /*opt-block*/
12435                                             
12436                                             break;
12437                                           case 2: 
12438                                             MATCH_w_8_24 = 
12439                                               getByte(3 + MATCH_p); 
12440                                             if ((MATCH_w_8_16 & 0x7) 
12441                                                     /* r_m at 16 */ == 4 && 
12442                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12443                                                     /* index at 24 */ && 
12444                                               (MATCH_w_8_24 >> 3 & 0x7) 
12445                                                     /* index at 24 */ < 8)) { 
12446                                               MATCH_w_16_64 = 
12447                                                 getWord(8 + MATCH_p); 
12448                                               goto MATCH_label_a467; 
12449                                               
12450                                             } /*opt-block*/
12451                                             else { 
12452                                               MATCH_w_16_56 = 
12453                                                 getWord(7 + MATCH_p); 
12454                                               goto MATCH_label_a468; 
12455                                               
12456                                             } /*opt-block*/
12457                                             
12458                                             break;
12459                                           case 3: 
12460                                             MATCH_w_16_24 = 
12461                                               getWord(3 + MATCH_p); 
12462                                             goto MATCH_label_a465; 
12463                                             
12464                                             break;
12465                                           default: assert(0);
12466                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
12467                                               -- mod at 16 --*/ 
12468                                       break;
12469                                     default: assert(0);
12470                                   } /* (MATCH_w_8_16 >> 3 & 0x7) 
12471                                         -- reg_opcode at 16 --*/ 
12472                                 
12473                               } /*opt-block*/
12474                               break;
12475                             case 3: 
12476                               if ((MATCH_w_8_8 >> 3 & 0x1) 
12477                                       /* page at 8 */ == 1) { 
12478                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
12479                                 
12480                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
12481                                         /* mod at 16 */) {
12482                                     case 0: 
12483                                       
12484                                         switch((MATCH_w_8_16 & 0x7) 
12485                                               /* r_m at 16 */) {
12486                                           case 0: case 1: case 2: case 3: 
12487                                           case 6: case 7: 
12488                                             goto MATCH_label_a505; break;
12489                                           case 4: 
12490                                             MATCH_w_8_24 = 
12491                                               getByte(3 + MATCH_p); 
12492                                             if ((MATCH_w_8_24 & 0x7) 
12493                                                     /* base at 24 */ == 5 && 
12494                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12495                                                     /* index at 24 */ && 
12496                                               (MATCH_w_8_24 >> 3 & 0x7) 
12497                                                     /* index at 24 */ < 8)) 
12498                                               goto MATCH_label_a507;  /*opt-block+*/
12499                                             else 
12500                                               goto MATCH_label_a506;  /*opt-block+*/
12501                                             
12502                                             break;
12503                                           case 5: 
12504                                             goto MATCH_label_a508; break;
12505                                           default: assert(0);
12506                                         } /* (MATCH_w_8_16 & 0x7) 
12507                                               -- r_m at 16 --*/ 
12508                                       break;
12509                                     case 1: 
12510                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
12511                                       if ((MATCH_w_8_16 & 0x7) 
12512                                               /* r_m at 16 */ == 4 && 
12513                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12514                                               /* index at 24 */ && 
12515                                         (MATCH_w_8_24 >> 3 & 0x7) 
12516                                               /* index at 24 */ < 8)) { 
12517                                         unsigned Eaddr = 
12518                                           2 + addressToPC(MATCH_p);
12519                                         unsigned reg = 
12520                                           (MATCH_w_8_16 >> 3 & 0x7) 
12521                                                 /* reg_opcode at 16 */;
12522                                         nextPC = 5 + MATCH_p; 
12523                                         
12524                                         #line 730 "machine/pentium/disassembler.m"
12525                                         
12526 
12527                                                 sprintf (str,  "MOVrmow", DIS_REG16, DIS_EADDR16);
12528 
12529                                         
12530 
12531                                         
12532                                         
12533                                         
12534                                       } /*opt-block*//*opt-block+*/
12535                                       else 
12536                                         goto MATCH_label_a506;  /*opt-block+*/
12537                                       
12538                                       break;
12539                                     case 2: 
12540                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
12541                                       if ((MATCH_w_8_16 & 0x7) 
12542                                               /* r_m at 16 */ == 4 && 
12543                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12544                                               /* index at 24 */ && 
12545                                         (MATCH_w_8_24 >> 3 & 0x7) 
12546                                               /* index at 24 */ < 8)) 
12547                                         goto MATCH_label_a507;  /*opt-block+*/
12548                                       else 
12549                                         goto MATCH_label_a508;  /*opt-block+*/
12550                                       
12551                                       break;
12552                                     case 3: 
12553                                       goto MATCH_label_a505; break;
12554                                     default: assert(0);
12555                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
12556                                         -- mod at 16 --*/ 
12557                                 
12558                               } /*opt-block*/
12559                               else { 
12560                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
12561                                 
12562                                   switch((MATCH_w_8_16 >> 3 & 0x7) 
12563                                         /* reg_opcode at 16 */) {
12564                                     case 0: 
12565                                       
12566                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
12567                                               /* mod at 16 */) {
12568                                           case 0: 
12569                                             
12570                                               switch((MATCH_w_8_16 & 0x7) 
12571                                                     /* r_m at 16 */) {
12572                                                 case 0: case 1: case 2: 
12573                                                 case 3: case 6: case 7: 
12574                                                   MATCH_w_8_24 = 
12575                                                     getByte(3 + MATCH_p); 
12576                                                   goto MATCH_label_a473; 
12577                                                   
12578                                                   break;
12579                                                 case 4: 
12580                                                   MATCH_w_8_24 = 
12581                                                     getByte(3 + MATCH_p); 
12582                                                   if ((MATCH_w_8_24 & 0x7) 
12583                                                           /* base at 24 */ == 5 && 
12584                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12585                                                           /* index at 24 */ && 
12586                                                     (MATCH_w_8_24 >> 3 & 0x7) 
12587                                                           /* index at 24 */ < 8)) { 
12588                                                     MATCH_w_8_64 = 
12589                                                       getByte(8 + MATCH_p); 
12590                                                     goto MATCH_label_a475; 
12591                                                     
12592                                                   } /*opt-block*/
12593                                                   else { 
12594                                                     MATCH_w_8_32 = 
12595                                                       getByte(4 + MATCH_p); 
12596                                                     goto MATCH_label_a474; 
12597                                                     
12598                                                   } /*opt-block*/
12599                                                   
12600                                                   break;
12601                                                 case 5: 
12602                                                   MATCH_w_8_56 = 
12603                                                     getByte(7 + MATCH_p); 
12604                                                   goto MATCH_label_a476; 
12605                                                   
12606                                                   break;
12607                                                 default: assert(0);
12608                                               } /* (MATCH_w_8_16 & 0x7) 
12609                                                     -- r_m at 16 --*/ 
12610                                             break;
12611                                           case 1: 
12612                                             MATCH_w_8_24 = 
12613                                               getByte(3 + MATCH_p); 
12614                                             if ((MATCH_w_8_16 & 0x7) 
12615                                                     /* r_m at 16 */ == 4 && 
12616                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12617                                                     /* index at 24 */ && 
12618                                               (MATCH_w_8_24 >> 3 & 0x7) 
12619                                                     /* index at 24 */ < 8)) { 
12620                                               MATCH_w_8_40 = 
12621                                                 getByte(5 + MATCH_p); 
12622                                               { 
12623                                                 unsigned Eaddr = 
12624                                                   2 + addressToPC(MATCH_p);
12625                                                 int /* [~128..127] */ i8 = 
12626                                                   sign_extend(
12627                                                               (MATCH_w_8_40 & 0xff) 
12628                                                                     /* i8 at 40 */, 
12629                                                               8);
12630                                                 nextPC = 6 + MATCH_p; 
12631                                                 
12632                                                 #line 1267 "machine/pentium/disassembler.m"
12633                                                 
12634 
12635                                                         sprintf (str,  "ADDiowb", DIS_EADDR16, DIS_I8);
12636 
12637                                                 
12638 
12639                                                 
12640                                                 
12641                                                 
12642                                               }
12643                                               
12644                                             } /*opt-block*/
12645                                             else { 
12646                                               MATCH_w_8_32 = 
12647                                                 getByte(4 + MATCH_p); 
12648                                               goto MATCH_label_a474; 
12649                                               
12650                                             } /*opt-block*/
12651                                             
12652                                             break;
12653                                           case 2: 
12654                                             MATCH_w_8_24 = 
12655                                               getByte(3 + MATCH_p); 
12656                                             if ((MATCH_w_8_16 & 0x7) 
12657                                                     /* r_m at 16 */ == 4 && 
12658                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12659                                                     /* index at 24 */ && 
12660                                               (MATCH_w_8_24 >> 3 & 0x7) 
12661                                                     /* index at 24 */ < 8)) { 
12662                                               MATCH_w_8_64 = 
12663                                                 getByte(8 + MATCH_p); 
12664                                               goto MATCH_label_a475; 
12665                                               
12666                                             } /*opt-block*/
12667                                             else { 
12668                                               MATCH_w_8_56 = 
12669                                                 getByte(7 + MATCH_p); 
12670                                               goto MATCH_label_a476; 
12671                                               
12672                                             } /*opt-block*/
12673                                             
12674                                             break;
12675                                           case 3: 
12676                                             MATCH_w_8_24 = 
12677                                               getByte(3 + MATCH_p); 
12678                                             goto MATCH_label_a473; 
12679                                             
12680                                             break;
12681                                           default: assert(0);
12682                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
12683                                               -- mod at 16 --*/ 
12684                                       break;
12685                                     case 1: 
12686                                       
12687                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
12688                                               /* mod at 16 */) {
12689                                           case 0: 
12690                                             
12691                                               switch((MATCH_w_8_16 & 0x7) 
12692                                                     /* r_m at 16 */) {
12693                                                 case 0: case 1: case 2: 
12694                                                 case 3: case 6: case 7: 
12695                                                   MATCH_w_8_24 = 
12696                                                     getByte(3 + MATCH_p); 
12697                                                   goto MATCH_label_a477; 
12698                                                   
12699                                                   break;
12700                                                 case 4: 
12701                                                   MATCH_w_8_24 = 
12702                                                     getByte(3 + MATCH_p); 
12703                                                   if ((MATCH_w_8_24 & 0x7) 
12704                                                           /* base at 24 */ == 5 && 
12705                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12706                                                           /* index at 24 */ && 
12707                                                     (MATCH_w_8_24 >> 3 & 0x7) 
12708                                                           /* index at 24 */ < 8)) { 
12709                                                     MATCH_w_8_64 = 
12710                                                       getByte(8 + MATCH_p); 
12711                                                     goto MATCH_label_a479; 
12712                                                     
12713                                                   } /*opt-block*/
12714                                                   else { 
12715                                                     MATCH_w_8_32 = 
12716                                                       getByte(4 + MATCH_p); 
12717                                                     goto MATCH_label_a478; 
12718                                                     
12719                                                   } /*opt-block*/
12720                                                   
12721                                                   break;
12722                                                 case 5: 
12723                                                   MATCH_w_8_56 = 
12724                                                     getByte(7 + MATCH_p); 
12725                                                   goto MATCH_label_a480; 
12726                                                   
12727                                                   break;
12728                                                 default: assert(0);
12729                                               } /* (MATCH_w_8_16 & 0x7) 
12730                                                     -- r_m at 16 --*/ 
12731                                             break;
12732                                           case 1: 
12733                                             MATCH_w_8_24 = 
12734                                               getByte(3 + MATCH_p); 
12735                                             if ((MATCH_w_8_16 & 0x7) 
12736                                                     /* r_m at 16 */ == 4 && 
12737                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12738                                                     /* index at 24 */ && 
12739                                               (MATCH_w_8_24 >> 3 & 0x7) 
12740                                                     /* index at 24 */ < 8)) { 
12741                                               MATCH_w_8_40 = 
12742                                                 getByte(5 + MATCH_p); 
12743                                               { 
12744                                                 unsigned Eaddr = 
12745                                                   2 + addressToPC(MATCH_p);
12746                                                 int /* [~128..127] */ i8 = 
12747                                                   sign_extend(
12748                                                               (MATCH_w_8_40 & 0xff) 
12749                                                                     /* i8 at 40 */, 
12750                                                               8);
12751                                                 nextPC = 6 + MATCH_p; 
12752                                                 
12753                                                 #line 1261 "machine/pentium/disassembler.m"
12754                                                 
12755 
12756                                                         sprintf (str,  "ORiowb", DIS_EADDR16, DIS_I8);
12757 
12758                                                 
12759 
12760                                                 
12761                                                 
12762                                                 
12763                                               }
12764                                               
12765                                             } /*opt-block*/
12766                                             else { 
12767                                               MATCH_w_8_32 = 
12768                                                 getByte(4 + MATCH_p); 
12769                                               goto MATCH_label_a478; 
12770                                               
12771                                             } /*opt-block*/
12772                                             
12773                                             break;
12774                                           case 2: 
12775                                             MATCH_w_8_24 = 
12776                                               getByte(3 + MATCH_p); 
12777                                             if ((MATCH_w_8_16 & 0x7) 
12778                                                     /* r_m at 16 */ == 4 && 
12779                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12780                                                     /* index at 24 */ && 
12781                                               (MATCH_w_8_24 >> 3 & 0x7) 
12782                                                     /* index at 24 */ < 8)) { 
12783                                               MATCH_w_8_64 = 
12784                                                 getByte(8 + MATCH_p); 
12785                                               goto MATCH_label_a479; 
12786                                               
12787                                             } /*opt-block*/
12788                                             else { 
12789                                               MATCH_w_8_56 = 
12790                                                 getByte(7 + MATCH_p); 
12791                                               goto MATCH_label_a480; 
12792                                               
12793                                             } /*opt-block*/
12794                                             
12795                                             break;
12796                                           case 3: 
12797                                             MATCH_w_8_24 = 
12798                                               getByte(3 + MATCH_p); 
12799                                             goto MATCH_label_a477; 
12800                                             
12801                                             break;
12802                                           default: assert(0);
12803                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
12804                                               -- mod at 16 --*/ 
12805                                       break;
12806                                     case 2: 
12807                                       
12808                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
12809                                               /* mod at 16 */) {
12810                                           case 0: 
12811                                             
12812                                               switch((MATCH_w_8_16 & 0x7) 
12813                                                     /* r_m at 16 */) {
12814                                                 case 0: case 1: case 2: 
12815                                                 case 3: case 6: case 7: 
12816                                                   MATCH_w_8_24 = 
12817                                                     getByte(3 + MATCH_p); 
12818                                                   goto MATCH_label_a481; 
12819                                                   
12820                                                   break;
12821                                                 case 4: 
12822                                                   MATCH_w_8_24 = 
12823                                                     getByte(3 + MATCH_p); 
12824                                                   if ((MATCH_w_8_24 & 0x7) 
12825                                                           /* base at 24 */ == 5 && 
12826                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12827                                                           /* index at 24 */ && 
12828                                                     (MATCH_w_8_24 >> 3 & 0x7) 
12829                                                           /* index at 24 */ < 8)) { 
12830                                                     MATCH_w_8_64 = 
12831                                                       getByte(8 + MATCH_p); 
12832                                                     goto MATCH_label_a483; 
12833                                                     
12834                                                   } /*opt-block*/
12835                                                   else { 
12836                                                     MATCH_w_8_32 = 
12837                                                       getByte(4 + MATCH_p); 
12838                                                     goto MATCH_label_a482; 
12839                                                     
12840                                                   } /*opt-block*/
12841                                                   
12842                                                   break;
12843                                                 case 5: 
12844                                                   MATCH_w_8_56 = 
12845                                                     getByte(7 + MATCH_p); 
12846                                                   goto MATCH_label_a484; 
12847                                                   
12848                                                   break;
12849                                                 default: assert(0);
12850                                               } /* (MATCH_w_8_16 & 0x7) 
12851                                                     -- r_m at 16 --*/ 
12852                                             break;
12853                                           case 1: 
12854                                             MATCH_w_8_24 = 
12855                                               getByte(3 + MATCH_p); 
12856                                             if ((MATCH_w_8_16 & 0x7) 
12857                                                     /* r_m at 16 */ == 4 && 
12858                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12859                                                     /* index at 24 */ && 
12860                                               (MATCH_w_8_24 >> 3 & 0x7) 
12861                                                     /* index at 24 */ < 8)) { 
12862                                               MATCH_w_8_40 = 
12863                                                 getByte(5 + MATCH_p); 
12864                                               { 
12865                                                 unsigned Eaddr = 
12866                                                   2 + addressToPC(MATCH_p);
12867                                                 int /* [~128..127] */ i8 = 
12868                                                   sign_extend(
12869                                                               (MATCH_w_8_40 & 0xff) 
12870                                                                     /* i8 at 40 */, 
12871                                                               8);
12872                                                 nextPC = 6 + MATCH_p; 
12873                                                 
12874                                                 #line 1255 "machine/pentium/disassembler.m"
12875                                                 
12876 
12877                                                         sprintf (str,  "ADCiowb", DIS_EADDR16, DIS_I8);
12878 
12879                                                 
12880 
12881                                                 
12882                                                 
12883                                                 
12884                                               }
12885                                               
12886                                             } /*opt-block*/
12887                                             else { 
12888                                               MATCH_w_8_32 = 
12889                                                 getByte(4 + MATCH_p); 
12890                                               goto MATCH_label_a482; 
12891                                               
12892                                             } /*opt-block*/
12893                                             
12894                                             break;
12895                                           case 2: 
12896                                             MATCH_w_8_24 = 
12897                                               getByte(3 + MATCH_p); 
12898                                             if ((MATCH_w_8_16 & 0x7) 
12899                                                     /* r_m at 16 */ == 4 && 
12900                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12901                                                     /* index at 24 */ && 
12902                                               (MATCH_w_8_24 >> 3 & 0x7) 
12903                                                     /* index at 24 */ < 8)) { 
12904                                               MATCH_w_8_64 = 
12905                                                 getByte(8 + MATCH_p); 
12906                                               goto MATCH_label_a483; 
12907                                               
12908                                             } /*opt-block*/
12909                                             else { 
12910                                               MATCH_w_8_56 = 
12911                                                 getByte(7 + MATCH_p); 
12912                                               goto MATCH_label_a484; 
12913                                               
12914                                             } /*opt-block*/
12915                                             
12916                                             break;
12917                                           case 3: 
12918                                             MATCH_w_8_24 = 
12919                                               getByte(3 + MATCH_p); 
12920                                             goto MATCH_label_a481; 
12921                                             
12922                                             break;
12923                                           default: assert(0);
12924                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
12925                                               -- mod at 16 --*/ 
12926                                       break;
12927                                     case 3: 
12928                                       
12929                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
12930                                               /* mod at 16 */) {
12931                                           case 0: 
12932                                             
12933                                               switch((MATCH_w_8_16 & 0x7) 
12934                                                     /* r_m at 16 */) {
12935                                                 case 0: case 1: case 2: 
12936                                                 case 3: case 6: case 7: 
12937                                                   MATCH_w_8_24 = 
12938                                                     getByte(3 + MATCH_p); 
12939                                                   goto MATCH_label_a485; 
12940                                                   
12941                                                   break;
12942                                                 case 4: 
12943                                                   MATCH_w_8_24 = 
12944                                                     getByte(3 + MATCH_p); 
12945                                                   if ((MATCH_w_8_24 & 0x7) 
12946                                                           /* base at 24 */ == 5 && 
12947                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12948                                                           /* index at 24 */ && 
12949                                                     (MATCH_w_8_24 >> 3 & 0x7) 
12950                                                           /* index at 24 */ < 8)) { 
12951                                                     MATCH_w_8_64 = 
12952                                                       getByte(8 + MATCH_p); 
12953                                                     goto MATCH_label_a487; 
12954                                                     
12955                                                   } /*opt-block*/
12956                                                   else { 
12957                                                     MATCH_w_8_32 = 
12958                                                       getByte(4 + MATCH_p); 
12959                                                     goto MATCH_label_a486; 
12960                                                     
12961                                                   } /*opt-block*/
12962                                                   
12963                                                   break;
12964                                                 case 5: 
12965                                                   MATCH_w_8_56 = 
12966                                                     getByte(7 + MATCH_p); 
12967                                                   goto MATCH_label_a488; 
12968                                                   
12969                                                   break;
12970                                                 default: assert(0);
12971                                               } /* (MATCH_w_8_16 & 0x7) 
12972                                                     -- r_m at 16 --*/ 
12973                                             break;
12974                                           case 1: 
12975                                             MATCH_w_8_24 = 
12976                                               getByte(3 + MATCH_p); 
12977                                             if ((MATCH_w_8_16 & 0x7) 
12978                                                     /* r_m at 16 */ == 4 && 
12979                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
12980                                                     /* index at 24 */ && 
12981                                               (MATCH_w_8_24 >> 3 & 0x7) 
12982                                                     /* index at 24 */ < 8)) { 
12983                                               MATCH_w_8_40 = 
12984                                                 getByte(5 + MATCH_p); 
12985                                               { 
12986                                                 unsigned Eaddr = 
12987                                                   2 + addressToPC(MATCH_p);
12988                                                 int /* [~128..127] */ i8 = 
12989                                                   sign_extend(
12990                                                               (MATCH_w_8_40 & 0xff) 
12991                                                                     /* i8 at 40 */, 
12992                                                               8);
12993                                                 nextPC = 6 + MATCH_p; 
12994                                                 
12995                                                 #line 1249 "machine/pentium/disassembler.m"
12996                                                 
12997 
12998                                                         sprintf (str,  "SBBiowb", DIS_EADDR16, DIS_I8);
12999 
13000                                                 
13001 
13002                                                 
13003                                                 
13004                                                 
13005                                               }
13006                                               
13007                                             } /*opt-block*/
13008                                             else { 
13009                                               MATCH_w_8_32 = 
13010                                                 getByte(4 + MATCH_p); 
13011                                               goto MATCH_label_a486; 
13012                                               
13013                                             } /*opt-block*/
13014                                             
13015                                             break;
13016                                           case 2: 
13017                                             MATCH_w_8_24 = 
13018                                               getByte(3 + MATCH_p); 
13019                                             if ((MATCH_w_8_16 & 0x7) 
13020                                                     /* r_m at 16 */ == 4 && 
13021                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13022                                                     /* index at 24 */ && 
13023                                               (MATCH_w_8_24 >> 3 & 0x7) 
13024                                                     /* index at 24 */ < 8)) { 
13025                                               MATCH_w_8_64 = 
13026                                                 getByte(8 + MATCH_p); 
13027                                               goto MATCH_label_a487; 
13028                                               
13029                                             } /*opt-block*/
13030                                             else { 
13031                                               MATCH_w_8_56 = 
13032                                                 getByte(7 + MATCH_p); 
13033                                               goto MATCH_label_a488; 
13034                                               
13035                                             } /*opt-block*/
13036                                             
13037                                             break;
13038                                           case 3: 
13039                                             MATCH_w_8_24 = 
13040                                               getByte(3 + MATCH_p); 
13041                                             goto MATCH_label_a485; 
13042                                             
13043                                             break;
13044                                           default: assert(0);
13045                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
13046                                               -- mod at 16 --*/ 
13047                                       break;
13048                                     case 4: 
13049                                       
13050                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
13051                                               /* mod at 16 */) {
13052                                           case 0: 
13053                                             
13054                                               switch((MATCH_w_8_16 & 0x7) 
13055                                                     /* r_m at 16 */) {
13056                                                 case 0: case 1: case 2: 
13057                                                 case 3: case 6: case 7: 
13058                                                   MATCH_w_8_24 = 
13059                                                     getByte(3 + MATCH_p); 
13060                                                   goto MATCH_label_a489; 
13061                                                   
13062                                                   break;
13063                                                 case 4: 
13064                                                   MATCH_w_8_24 = 
13065                                                     getByte(3 + MATCH_p); 
13066                                                   if ((MATCH_w_8_24 & 0x7) 
13067                                                           /* base at 24 */ == 5 && 
13068                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13069                                                           /* index at 24 */ && 
13070                                                     (MATCH_w_8_24 >> 3 & 0x7) 
13071                                                           /* index at 24 */ < 8)) { 
13072                                                     MATCH_w_8_64 = 
13073                                                       getByte(8 + MATCH_p); 
13074                                                     goto MATCH_label_a491; 
13075                                                     
13076                                                   } /*opt-block*/
13077                                                   else { 
13078                                                     MATCH_w_8_32 = 
13079                                                       getByte(4 + MATCH_p); 
13080                                                     goto MATCH_label_a490; 
13081                                                     
13082                                                   } /*opt-block*/
13083                                                   
13084                                                   break;
13085                                                 case 5: 
13086                                                   MATCH_w_8_56 = 
13087                                                     getByte(7 + MATCH_p); 
13088                                                   goto MATCH_label_a492; 
13089                                                   
13090                                                   break;
13091                                                 default: assert(0);
13092                                               } /* (MATCH_w_8_16 & 0x7) 
13093                                                     -- r_m at 16 --*/ 
13094                                             break;
13095                                           case 1: 
13096                                             MATCH_w_8_24 = 
13097                                               getByte(3 + MATCH_p); 
13098                                             if ((MATCH_w_8_16 & 0x7) 
13099                                                     /* r_m at 16 */ == 4 && 
13100                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13101                                                     /* index at 24 */ && 
13102                                               (MATCH_w_8_24 >> 3 & 0x7) 
13103                                                     /* index at 24 */ < 8)) { 
13104                                               MATCH_w_8_40 = 
13105                                                 getByte(5 + MATCH_p); 
13106                                               { 
13107                                                 unsigned Eaddr = 
13108                                                   2 + addressToPC(MATCH_p);
13109                                                 int /* [~128..127] */ i8 = 
13110                                                   sign_extend(
13111                                                               (MATCH_w_8_40 & 0xff) 
13112                                                                     /* i8 at 40 */, 
13113                                                               8);
13114                                                 nextPC = 6 + MATCH_p; 
13115                                                 
13116                                                 #line 1243 "machine/pentium/disassembler.m"
13117                                                 
13118 
13119                                                         sprintf (str,  "ANDiowb", DIS_EADDR16, DIS_I8);
13120 
13121                                                 
13122 
13123                                                 
13124                                                 
13125                                                 
13126                                               }
13127                                               
13128                                             } /*opt-block*/
13129                                             else { 
13130                                               MATCH_w_8_32 = 
13131                                                 getByte(4 + MATCH_p); 
13132                                               goto MATCH_label_a490; 
13133                                               
13134                                             } /*opt-block*/
13135                                             
13136                                             break;
13137                                           case 2: 
13138                                             MATCH_w_8_24 = 
13139                                               getByte(3 + MATCH_p); 
13140                                             if ((MATCH_w_8_16 & 0x7) 
13141                                                     /* r_m at 16 */ == 4 && 
13142                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13143                                                     /* index at 24 */ && 
13144                                               (MATCH_w_8_24 >> 3 & 0x7) 
13145                                                     /* index at 24 */ < 8)) { 
13146                                               MATCH_w_8_64 = 
13147                                                 getByte(8 + MATCH_p); 
13148                                               goto MATCH_label_a491; 
13149                                               
13150                                             } /*opt-block*/
13151                                             else { 
13152                                               MATCH_w_8_56 = 
13153                                                 getByte(7 + MATCH_p); 
13154                                               goto MATCH_label_a492; 
13155                                               
13156                                             } /*opt-block*/
13157                                             
13158                                             break;
13159                                           case 3: 
13160                                             MATCH_w_8_24 = 
13161                                               getByte(3 + MATCH_p); 
13162                                             goto MATCH_label_a489; 
13163                                             
13164                                             break;
13165                                           default: assert(0);
13166                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
13167                                               -- mod at 16 --*/ 
13168                                       break;
13169                                     case 5: 
13170                                       
13171                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
13172                                               /* mod at 16 */) {
13173                                           case 0: 
13174                                             
13175                                               switch((MATCH_w_8_16 & 0x7) 
13176                                                     /* r_m at 16 */) {
13177                                                 case 0: case 1: case 2: 
13178                                                 case 3: case 6: case 7: 
13179                                                   MATCH_w_8_24 = 
13180                                                     getByte(3 + MATCH_p); 
13181                                                   goto MATCH_label_a493; 
13182                                                   
13183                                                   break;
13184                                                 case 4: 
13185                                                   MATCH_w_8_24 = 
13186                                                     getByte(3 + MATCH_p); 
13187                                                   if ((MATCH_w_8_24 & 0x7) 
13188                                                           /* base at 24 */ == 5 && 
13189                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13190                                                           /* index at 24 */ && 
13191                                                     (MATCH_w_8_24 >> 3 & 0x7) 
13192                                                           /* index at 24 */ < 8)) { 
13193                                                     MATCH_w_8_64 = 
13194                                                       getByte(8 + MATCH_p); 
13195                                                     goto MATCH_label_a495; 
13196                                                     
13197                                                   } /*opt-block*/
13198                                                   else { 
13199                                                     MATCH_w_8_32 = 
13200                                                       getByte(4 + MATCH_p); 
13201                                                     goto MATCH_label_a494; 
13202                                                     
13203                                                   } /*opt-block*/
13204                                                   
13205                                                   break;
13206                                                 case 5: 
13207                                                   MATCH_w_8_56 = 
13208                                                     getByte(7 + MATCH_p); 
13209                                                   goto MATCH_label_a496; 
13210                                                   
13211                                                   break;
13212                                                 default: assert(0);
13213                                               } /* (MATCH_w_8_16 & 0x7) 
13214                                                     -- r_m at 16 --*/ 
13215                                             break;
13216                                           case 1: 
13217                                             MATCH_w_8_24 = 
13218                                               getByte(3 + MATCH_p); 
13219                                             if ((MATCH_w_8_16 & 0x7) 
13220                                                     /* r_m at 16 */ == 4 && 
13221                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13222                                                     /* index at 24 */ && 
13223                                               (MATCH_w_8_24 >> 3 & 0x7) 
13224                                                     /* index at 24 */ < 8)) { 
13225                                               MATCH_w_8_40 = 
13226                                                 getByte(5 + MATCH_p); 
13227                                               { 
13228                                                 unsigned Eaddr = 
13229                                                   2 + addressToPC(MATCH_p);
13230                                                 int /* [~128..127] */ i8 = 
13231                                                   sign_extend(
13232                                                               (MATCH_w_8_40 & 0xff) 
13233                                                                     /* i8 at 40 */, 
13234                                                               8);
13235                                                 nextPC = 6 + MATCH_p; 
13236                                                 
13237                                                 #line 1237 "machine/pentium/disassembler.m"
13238                                                 
13239 
13240                                                         sprintf (str,  "SUBiowb", DIS_EADDR16, DIS_I8);
13241 
13242                                                 
13243 
13244                                                 
13245                                                 
13246                                                 
13247                                               }
13248                                               
13249                                             } /*opt-block*/
13250                                             else { 
13251                                               MATCH_w_8_32 = 
13252                                                 getByte(4 + MATCH_p); 
13253                                               goto MATCH_label_a494; 
13254                                               
13255                                             } /*opt-block*/
13256                                             
13257                                             break;
13258                                           case 2: 
13259                                             MATCH_w_8_24 = 
13260                                               getByte(3 + MATCH_p); 
13261                                             if ((MATCH_w_8_16 & 0x7) 
13262                                                     /* r_m at 16 */ == 4 && 
13263                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13264                                                     /* index at 24 */ && 
13265                                               (MATCH_w_8_24 >> 3 & 0x7) 
13266                                                     /* index at 24 */ < 8)) { 
13267                                               MATCH_w_8_64 = 
13268                                                 getByte(8 + MATCH_p); 
13269                                               goto MATCH_label_a495; 
13270                                               
13271                                             } /*opt-block*/
13272                                             else { 
13273                                               MATCH_w_8_56 = 
13274                                                 getByte(7 + MATCH_p); 
13275                                               goto MATCH_label_a496; 
13276                                               
13277                                             } /*opt-block*/
13278                                             
13279                                             break;
13280                                           case 3: 
13281                                             MATCH_w_8_24 = 
13282                                               getByte(3 + MATCH_p); 
13283                                             goto MATCH_label_a493; 
13284                                             
13285                                             break;
13286                                           default: assert(0);
13287                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
13288                                               -- mod at 16 --*/ 
13289                                       break;
13290                                     case 6: 
13291                                       
13292                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
13293                                               /* mod at 16 */) {
13294                                           case 0: 
13295                                             
13296                                               switch((MATCH_w_8_16 & 0x7) 
13297                                                     /* r_m at 16 */) {
13298                                                 case 0: case 1: case 2: 
13299                                                 case 3: case 6: case 7: 
13300                                                   MATCH_w_8_24 = 
13301                                                     getByte(3 + MATCH_p); 
13302                                                   goto MATCH_label_a497; 
13303                                                   
13304                                                   break;
13305                                                 case 4: 
13306                                                   MATCH_w_8_24 = 
13307                                                     getByte(3 + MATCH_p); 
13308                                                   if ((MATCH_w_8_24 & 0x7) 
13309                                                           /* base at 24 */ == 5 && 
13310                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13311                                                           /* index at 24 */ && 
13312                                                     (MATCH_w_8_24 >> 3 & 0x7) 
13313                                                           /* index at 24 */ < 8)) { 
13314                                                     MATCH_w_8_64 = 
13315                                                       getByte(8 + MATCH_p); 
13316                                                     goto MATCH_label_a499; 
13317                                                     
13318                                                   } /*opt-block*/
13319                                                   else { 
13320                                                     MATCH_w_8_32 = 
13321                                                       getByte(4 + MATCH_p); 
13322                                                     goto MATCH_label_a498; 
13323                                                     
13324                                                   } /*opt-block*/
13325                                                   
13326                                                   break;
13327                                                 case 5: 
13328                                                   MATCH_w_8_56 = 
13329                                                     getByte(7 + MATCH_p); 
13330                                                   goto MATCH_label_a500; 
13331                                                   
13332                                                   break;
13333                                                 default: assert(0);
13334                                               } /* (MATCH_w_8_16 & 0x7) 
13335                                                     -- r_m at 16 --*/ 
13336                                             break;
13337                                           case 1: 
13338                                             MATCH_w_8_24 = 
13339                                               getByte(3 + MATCH_p); 
13340                                             if ((MATCH_w_8_16 & 0x7) 
13341                                                     /* r_m at 16 */ == 4 && 
13342                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13343                                                     /* index at 24 */ && 
13344                                               (MATCH_w_8_24 >> 3 & 0x7) 
13345                                                     /* index at 24 */ < 8)) { 
13346                                               MATCH_w_8_40 = 
13347                                                 getByte(5 + MATCH_p); 
13348                                               { 
13349                                                 unsigned Eaddr = 
13350                                                   2 + addressToPC(MATCH_p);
13351                                                 int /* [~128..127] */ i8 = 
13352                                                   sign_extend(
13353                                                               (MATCH_w_8_40 & 0xff) 
13354                                                                     /* i8 at 40 */, 
13355                                                               8);
13356                                                 nextPC = 6 + MATCH_p; 
13357                                                 
13358                                                 #line 1231 "machine/pentium/disassembler.m"
13359                                                 
13360 
13361                                                         sprintf (str,  "XORiowb", DIS_EADDR16, DIS_I8);
13362 
13363                                                 
13364 
13365                                                 
13366                                                 
13367                                                 
13368                                               }
13369                                               
13370                                             } /*opt-block*/
13371                                             else { 
13372                                               MATCH_w_8_32 = 
13373                                                 getByte(4 + MATCH_p); 
13374                                               goto MATCH_label_a498; 
13375                                               
13376                                             } /*opt-block*/
13377                                             
13378                                             break;
13379                                           case 2: 
13380                                             MATCH_w_8_24 = 
13381                                               getByte(3 + MATCH_p); 
13382                                             if ((MATCH_w_8_16 & 0x7) 
13383                                                     /* r_m at 16 */ == 4 && 
13384                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13385                                                     /* index at 24 */ && 
13386                                               (MATCH_w_8_24 >> 3 & 0x7) 
13387                                                     /* index at 24 */ < 8)) { 
13388                                               MATCH_w_8_64 = 
13389                                                 getByte(8 + MATCH_p); 
13390                                               goto MATCH_label_a499; 
13391                                               
13392                                             } /*opt-block*/
13393                                             else { 
13394                                               MATCH_w_8_56 = 
13395                                                 getByte(7 + MATCH_p); 
13396                                               goto MATCH_label_a500; 
13397                                               
13398                                             } /*opt-block*/
13399                                             
13400                                             break;
13401                                           case 3: 
13402                                             MATCH_w_8_24 = 
13403                                               getByte(3 + MATCH_p); 
13404                                             goto MATCH_label_a497; 
13405                                             
13406                                             break;
13407                                           default: assert(0);
13408                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
13409                                               -- mod at 16 --*/ 
13410                                       break;
13411                                     case 7: 
13412                                       
13413                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
13414                                               /* mod at 16 */) {
13415                                           case 0: 
13416                                             
13417                                               switch((MATCH_w_8_16 & 0x7) 
13418                                                     /* r_m at 16 */) {
13419                                                 case 0: case 1: case 2: 
13420                                                 case 3: case 6: case 7: 
13421                                                   MATCH_w_8_24 = 
13422                                                     getByte(3 + MATCH_p); 
13423                                                   goto MATCH_label_a501; 
13424                                                   
13425                                                   break;
13426                                                 case 4: 
13427                                                   MATCH_w_8_24 = 
13428                                                     getByte(3 + MATCH_p); 
13429                                                   if ((MATCH_w_8_24 & 0x7) 
13430                                                           /* base at 24 */ == 5 && 
13431                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13432                                                           /* index at 24 */ && 
13433                                                     (MATCH_w_8_24 >> 3 & 0x7) 
13434                                                           /* index at 24 */ < 8)) { 
13435                                                     MATCH_w_8_64 = 
13436                                                       getByte(8 + MATCH_p); 
13437                                                     goto MATCH_label_a503; 
13438                                                     
13439                                                   } /*opt-block*/
13440                                                   else { 
13441                                                     MATCH_w_8_32 = 
13442                                                       getByte(4 + MATCH_p); 
13443                                                     goto MATCH_label_a502; 
13444                                                     
13445                                                   } /*opt-block*/
13446                                                   
13447                                                   break;
13448                                                 case 5: 
13449                                                   MATCH_w_8_56 = 
13450                                                     getByte(7 + MATCH_p); 
13451                                                   goto MATCH_label_a504; 
13452                                                   
13453                                                   break;
13454                                                 default: assert(0);
13455                                               } /* (MATCH_w_8_16 & 0x7) 
13456                                                     -- r_m at 16 --*/ 
13457                                             break;
13458                                           case 1: 
13459                                             MATCH_w_8_24 = 
13460                                               getByte(3 + MATCH_p); 
13461                                             if ((MATCH_w_8_16 & 0x7) 
13462                                                     /* r_m at 16 */ == 4 && 
13463                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13464                                                     /* index at 24 */ && 
13465                                               (MATCH_w_8_24 >> 3 & 0x7) 
13466                                                     /* index at 24 */ < 8)) { 
13467                                               MATCH_w_8_40 = 
13468                                                 getByte(5 + MATCH_p); 
13469                                               { 
13470                                                 unsigned Eaddr = 
13471                                                   2 + addressToPC(MATCH_p);
13472                                                 int /* [~128..127] */ i8 = 
13473                                                   sign_extend(
13474                                                               (MATCH_w_8_40 & 0xff) 
13475                                                                     /* i8 at 40 */, 
13476                                                               8);
13477                                                 nextPC = 6 + MATCH_p; 
13478                                                 
13479                                                 #line 1225 "machine/pentium/disassembler.m"
13480                                                 
13481 
13482                                                         sprintf (str,  "CMPiowb", DIS_EADDR16, DIS_I8);
13483 
13484                                                 
13485 
13486                                                 
13487                                                 
13488                                                 
13489                                               }
13490                                               
13491                                             } /*opt-block*/
13492                                             else { 
13493                                               MATCH_w_8_32 = 
13494                                                 getByte(4 + MATCH_p); 
13495                                               goto MATCH_label_a502; 
13496                                               
13497                                             } /*opt-block*/
13498                                             
13499                                             break;
13500                                           case 2: 
13501                                             MATCH_w_8_24 = 
13502                                               getByte(3 + MATCH_p); 
13503                                             if ((MATCH_w_8_16 & 0x7) 
13504                                                     /* r_m at 16 */ == 4 && 
13505                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13506                                                     /* index at 24 */ && 
13507                                               (MATCH_w_8_24 >> 3 & 0x7) 
13508                                                     /* index at 24 */ < 8)) { 
13509                                               MATCH_w_8_64 = 
13510                                                 getByte(8 + MATCH_p); 
13511                                               goto MATCH_label_a503; 
13512                                               
13513                                             } /*opt-block*/
13514                                             else { 
13515                                               MATCH_w_8_56 = 
13516                                                 getByte(7 + MATCH_p); 
13517                                               goto MATCH_label_a504; 
13518                                               
13519                                             } /*opt-block*/
13520                                             
13521                                             break;
13522                                           case 3: 
13523                                             MATCH_w_8_24 = 
13524                                               getByte(3 + MATCH_p); 
13525                                             goto MATCH_label_a501; 
13526                                             
13527                                             break;
13528                                           default: assert(0);
13529                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
13530                                               -- mod at 16 --*/ 
13531                                       break;
13532                                     default: assert(0);
13533                                   } /* (MATCH_w_8_16 >> 3 & 0x7) 
13534                                         -- reg_opcode at 16 --*/ 
13535                                 
13536                               } /*opt-block*/
13537                               break;
13538                             case 5: 
13539                               if ((MATCH_w_8_8 >> 3 & 0x1) 
13540                                       /* page at 8 */ == 1) { 
13541                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
13542                                 
13543                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
13544                                         /* mod at 16 */) {
13545                                     case 0: 
13546                                       
13547                                         switch((MATCH_w_8_16 & 0x7) 
13548                                               /* r_m at 16 */) {
13549                                           case 0: case 1: case 2: case 3: 
13550                                           case 6: case 7: 
13551                                             { 
13552                                               unsigned Mem = 
13553                                                 2 + addressToPC(MATCH_p);
13554                                               unsigned reg = 
13555                                                 (MATCH_w_8_16 >> 3 & 0x7) 
13556                                                       /* reg_opcode at 16 */;
13557                                               nextPC = 3 + MATCH_p; 
13558                                               
13559                                               #line 781 "machine/pentium/disassembler.m"
13560                                               
13561 
13562                                                       sprintf (str,  "LEA.ow", DIS_REG16, DIS_MEM);
13563 
13564                                               
13565 
13566                                               
13567                                               
13568                                               
13569                                             }
13570                                             
13571                                             break;
13572                                           case 4: 
13573                                             MATCH_w_8_24 = 
13574                                               getByte(3 + MATCH_p); 
13575                                             if ((MATCH_w_8_24 & 0x7) 
13576                                                     /* base at 24 */ == 5 && 
13577                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13578                                                     /* index at 24 */ && 
13579                                               (MATCH_w_8_24 >> 3 & 0x7) 
13580                                                     /* index at 24 */ < 8)) 
13581                                               goto MATCH_label_a514;  /*opt-block+*/
13582                                             else 
13583                                               goto MATCH_label_a513;  /*opt-block+*/
13584                                             
13585                                             break;
13586                                           case 5: 
13587                                             goto MATCH_label_a515; break;
13588                                           default: assert(0);
13589                                         } /* (MATCH_w_8_16 & 0x7) 
13590                                               -- r_m at 16 --*/ 
13591                                       break;
13592                                     case 1: 
13593                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
13594                                       if ((MATCH_w_8_16 & 0x7) 
13595                                               /* r_m at 16 */ == 4 && 
13596                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13597                                               /* index at 24 */ && 
13598                                         (MATCH_w_8_24 >> 3 & 0x7) 
13599                                               /* index at 24 */ < 8)) { 
13600                                         unsigned Mem = 
13601                                           2 + addressToPC(MATCH_p);
13602                                         unsigned reg = 
13603                                           (MATCH_w_8_16 >> 3 & 0x7) 
13604                                                 /* reg_opcode at 16 */;
13605                                         nextPC = 5 + MATCH_p; 
13606                                         
13607                                         #line 781 "machine/pentium/disassembler.m"
13608                                         
13609 
13610                                                 sprintf (str,  "LEA.ow", DIS_REG16, DIS_MEM);
13611 
13612                                         
13613 
13614                                         
13615                                         
13616                                         
13617                                       } /*opt-block*//*opt-block+*/
13618                                       else 
13619                                         goto MATCH_label_a513;  /*opt-block+*/
13620                                       
13621                                       break;
13622                                     case 2: 
13623                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
13624                                       if ((MATCH_w_8_16 & 0x7) 
13625                                               /* r_m at 16 */ == 4 && 
13626                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13627                                               /* index at 24 */ && 
13628                                         (MATCH_w_8_24 >> 3 & 0x7) 
13629                                               /* index at 24 */ < 8)) 
13630                                         goto MATCH_label_a514;  /*opt-block+*/
13631                                       else 
13632                                         goto MATCH_label_a515;  /*opt-block+*/
13633                                       
13634                                       break;
13635                                     case 3: 
13636                                       goto MATCH_label_a39; break;
13637                                     default: assert(0);
13638                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
13639                                         -- mod at 16 --*/ 
13640                                 
13641                               } /*opt-block*/
13642                               else { 
13643                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
13644                                 
13645                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
13646                                         /* mod at 16 */) {
13647                                     case 0: 
13648                                       
13649                                         switch((MATCH_w_8_16 & 0x7) 
13650                                               /* r_m at 16 */) {
13651                                           case 0: case 1: case 2: case 3: 
13652                                           case 6: case 7: 
13653                                             goto MATCH_label_a509; break;
13654                                           case 4: 
13655                                             MATCH_w_8_24 = 
13656                                               getByte(3 + MATCH_p); 
13657                                             if ((MATCH_w_8_24 & 0x7) 
13658                                                     /* base at 24 */ == 5 && 
13659                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13660                                                     /* index at 24 */ && 
13661                                               (MATCH_w_8_24 >> 3 & 0x7) 
13662                                                     /* index at 24 */ < 8)) 
13663                                               goto MATCH_label_a511;  /*opt-block+*/
13664                                             else 
13665                                               goto MATCH_label_a510;  /*opt-block+*/
13666                                             
13667                                             break;
13668                                           case 5: 
13669                                             goto MATCH_label_a512; break;
13670                                           default: assert(0);
13671                                         } /* (MATCH_w_8_16 & 0x7) 
13672                                               -- r_m at 16 --*/ 
13673                                       break;
13674                                     case 1: 
13675                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
13676                                       if ((MATCH_w_8_16 & 0x7) 
13677                                               /* r_m at 16 */ == 4 && 
13678                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13679                                               /* index at 24 */ && 
13680                                         (MATCH_w_8_24 >> 3 & 0x7) 
13681                                               /* index at 24 */ < 8)) { 
13682                                         unsigned Eaddr = 
13683                                           2 + addressToPC(MATCH_p);
13684                                         unsigned reg = 
13685                                           (MATCH_w_8_16 >> 3 & 0x7) 
13686                                                 /* reg_opcode at 16 */;
13687                                         nextPC = 5 + MATCH_p; 
13688                                         
13689                                         #line 98 "machine/pentium/disassembler.m"
13690                                         
13691 
13692                                                 sprintf (str,  "TEST.Ev.Gvow", DIS_EADDR16, DIS_REG16);
13693 
13694                                         
13695 
13696                                         
13697                                         
13698                                         
13699                                       } /*opt-block*//*opt-block+*/
13700                                       else 
13701                                         goto MATCH_label_a510;  /*opt-block+*/
13702                                       
13703                                       break;
13704                                     case 2: 
13705                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
13706                                       if ((MATCH_w_8_16 & 0x7) 
13707                                               /* r_m at 16 */ == 4 && 
13708                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13709                                               /* index at 24 */ && 
13710                                         (MATCH_w_8_24 >> 3 & 0x7) 
13711                                               /* index at 24 */ < 8)) 
13712                                         goto MATCH_label_a511;  /*opt-block+*/
13713                                       else 
13714                                         goto MATCH_label_a512;  /*opt-block+*/
13715                                       
13716                                       break;
13717                                     case 3: 
13718                                       goto MATCH_label_a509; break;
13719                                     default: assert(0);
13720                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
13721                                         -- mod at 16 --*/ 
13722                                 
13723                               } /*opt-block*/
13724                               break;
13725                             case 7: 
13726                               if ((MATCH_w_8_8 >> 3 & 0x1) 
13727                                       /* page at 8 */ == 1) { 
13728                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
13729                                 if ((MATCH_w_8_16 >> 3 & 0x7) 
13730                                         /* reg_opcode at 16 */ == 0) 
13731                                   
13732                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
13733                                           /* mod at 16 */) {
13734                                       case 0: 
13735                                         
13736                                           switch((MATCH_w_8_16 & 0x7) 
13737                                                 /* r_m at 16 */) {
13738                                             case 0: case 1: case 2: case 3: 
13739                                             case 6: case 7: 
13740                                               { 
13741                                                 unsigned Mem = 
13742                                                   2 + addressToPC(MATCH_p);
13743                                                 nextPC = 3 + MATCH_p; 
13744                                                 
13745                                                 #line 585 "machine/pentium/disassembler.m"
13746                                                 
13747 
13748                                                         sprintf (str,  "POP.Evow", DIS_MEM);
13749 
13750                                                 
13751 
13752                                                 //    | OUTSvod() =>
13753 
13754                                                 //        sprintf (str,  "OUTSvod");
13755 
13756                                                 
13757 
13758                                                 //    | OUTSvow() =>
13759 
13760                                                 //        sprintf (str,  "OUTSvow");
13761 
13762                                                 
13763 
13764                                                 //    | OUTSB() =>
13765 
13766                                                 //        sprintf (str,  "OUTSB");
13767 
13768                                                 
13769 
13770                                                 //    | OUT.DX.eAXod() =>
13771 
13772                                                 //        sprintf (str,  "OUT.DX.eAXod");
13773 
13774                                                 
13775 
13776                                                 //    | OUT.DX.eAXow() =>
13777 
13778                                                 //        sprintf (str,  "OUT.DX.eAXow");
13779 
13780                                                 
13781 
13782                                                 //    | OUT.DX.AL() =>
13783 
13784                                                 //        sprintf (str,  "OUT.DX.AL");
13785 
13786                                                 
13787 
13788                                                 //    | OUT.Ib.eAXod(i8) =>
13789 
13790                                                 //        sprintf (str,  "OUT.Ib.eAXod", DIS_I8);
13791 
13792                                                 
13793 
13794                                                 //    | OUT.Ib.eAXow(i8) =>
13795 
13796                                                 //        sprintf (str,  "OUT.Ib.eAXow", DIS_I8);
13797 
13798                                                 
13799 
13800                                                 //    | OUT.Ib.AL(i8) =>
13801 
13802                                                 //        sprintf (str,  "OUT.Ib.AL", DIS_I8);
13803 
13804                                                 
13805 
13806                                                 
13807                                                 
13808                                                 
13809                                               }
13810                                               
13811                                               break;
13812                                             case 4: 
13813                                               MATCH_w_8_24 = 
13814                                                 getByte(3 + MATCH_p); 
13815                                               if ((MATCH_w_8_24 & 0x7) 
13816                                                       /* base at 24 */ == 5 && 
13817                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13818                                                       /* index at 24 */ && 
13819                                                 (MATCH_w_8_24 >> 3 & 0x7) 
13820                                                       /* index at 24 */ < 8)) 
13821                                                 goto MATCH_label_a521;  /*opt-block+*/
13822                                               else 
13823                                                 goto MATCH_label_a520;  /*opt-block+*/
13824                                               
13825                                               break;
13826                                             case 5: 
13827                                               goto MATCH_label_a522; break;
13828                                             default: assert(0);
13829                                           } /* (MATCH_w_8_16 & 0x7) 
13830                                                 -- r_m at 16 --*/ 
13831                                         break;
13832                                       case 1: 
13833                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
13834                                         if ((MATCH_w_8_16 & 0x7) 
13835                                                 /* r_m at 16 */ == 4 && 
13836                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13837                                                 /* index at 24 */ && 
13838                                           (MATCH_w_8_24 >> 3 & 0x7) 
13839                                                 /* index at 24 */ < 8)) { 
13840                                           unsigned Mem = 
13841                                             2 + addressToPC(MATCH_p);
13842                                           nextPC = 5 + MATCH_p; 
13843                                           
13844                                           #line 585 "machine/pentium/disassembler.m"
13845                                           
13846 
13847                                                   sprintf (str,  "POP.Evow", DIS_MEM);
13848 
13849                                           
13850 
13851                                           //    | OUTSvod() =>
13852 
13853                                           //        sprintf (str,  "OUTSvod");
13854 
13855                                           
13856 
13857                                           //    | OUTSvow() =>
13858 
13859                                           //        sprintf (str,  "OUTSvow");
13860 
13861                                           
13862 
13863                                           //    | OUTSB() =>
13864 
13865                                           //        sprintf (str,  "OUTSB");
13866 
13867                                           
13868 
13869                                           //    | OUT.DX.eAXod() =>
13870 
13871                                           //        sprintf (str,  "OUT.DX.eAXod");
13872 
13873                                           
13874 
13875                                           //    | OUT.DX.eAXow() =>
13876 
13877                                           //        sprintf (str,  "OUT.DX.eAXow");
13878 
13879                                           
13880 
13881                                           //    | OUT.DX.AL() =>
13882 
13883                                           //        sprintf (str,  "OUT.DX.AL");
13884 
13885                                           
13886 
13887                                           //    | OUT.Ib.eAXod(i8) =>
13888 
13889                                           //        sprintf (str,  "OUT.Ib.eAXod", DIS_I8);
13890 
13891                                           
13892 
13893                                           //    | OUT.Ib.eAXow(i8) =>
13894 
13895                                           //        sprintf (str,  "OUT.Ib.eAXow", DIS_I8);
13896 
13897                                           
13898 
13899                                           //    | OUT.Ib.AL(i8) =>
13900 
13901                                           //        sprintf (str,  "OUT.Ib.AL", DIS_I8);
13902 
13903                                           
13904 
13905                                           
13906                                           
13907                                           
13908                                         } /*opt-block*//*opt-block+*/
13909                                         else 
13910                                           goto MATCH_label_a520;  /*opt-block+*/
13911                                         
13912                                         break;
13913                                       case 2: 
13914                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
13915                                         if ((MATCH_w_8_16 & 0x7) 
13916                                                 /* r_m at 16 */ == 4 && 
13917                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13918                                                 /* index at 24 */ && 
13919                                           (MATCH_w_8_24 >> 3 & 0x7) 
13920                                                 /* index at 24 */ < 8)) 
13921                                           goto MATCH_label_a521;  /*opt-block+*/
13922                                         else 
13923                                           goto MATCH_label_a522;  /*opt-block+*/
13924                                         
13925                                         break;
13926                                       case 3: 
13927                                         goto MATCH_label_a39; break;
13928                                       default: assert(0);
13929                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
13930                                           -- mod at 16 --*/  
13931                                 else 
13932                                   goto MATCH_label_a39;  /*opt-block+*/
13933                                 
13934                               } /*opt-block*/
13935                               else { 
13936                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
13937                                 
13938                                   switch((MATCH_w_8_16 >> 6 & 0x3) 
13939                                         /* mod at 16 */) {
13940                                     case 0: 
13941                                       
13942                                         switch((MATCH_w_8_16 & 0x7) 
13943                                               /* r_m at 16 */) {
13944                                           case 0: case 1: case 2: case 3: 
13945                                           case 6: case 7: 
13946                                             goto MATCH_label_a516; break;
13947                                           case 4: 
13948                                             MATCH_w_8_24 = 
13949                                               getByte(3 + MATCH_p); 
13950                                             if ((MATCH_w_8_24 & 0x7) 
13951                                                     /* base at 24 */ == 5 && 
13952                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13953                                                     /* index at 24 */ && 
13954                                               (MATCH_w_8_24 >> 3 & 0x7) 
13955                                                     /* index at 24 */ < 8)) 
13956                                               goto MATCH_label_a518;  /*opt-block+*/
13957                                             else 
13958                                               goto MATCH_label_a517;  /*opt-block+*/
13959                                             
13960                                             break;
13961                                           case 5: 
13962                                             goto MATCH_label_a519; break;
13963                                           default: assert(0);
13964                                         } /* (MATCH_w_8_16 & 0x7) 
13965                                               -- r_m at 16 --*/ 
13966                                       break;
13967                                     case 1: 
13968                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
13969                                       if ((MATCH_w_8_16 & 0x7) 
13970                                               /* r_m at 16 */ == 4 && 
13971                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
13972                                               /* index at 24 */ && 
13973                                         (MATCH_w_8_24 >> 3 & 0x7) 
13974                                               /* index at 24 */ < 8)) { 
13975                                         unsigned Eaddr = 
13976                                           2 + addressToPC(MATCH_p);
13977                                         unsigned reg = 
13978                                           (MATCH_w_8_16 >> 3 & 0x7) 
13979                                                 /* reg_opcode at 16 */;
13980                                         nextPC = 5 + MATCH_p; 
13981                                         
13982                                         #line 50 "machine/pentium/disassembler.m"
13983                                         
13984 
13985                                                 sprintf (str, "%s %s,%s", "XCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
13986 
13987                                         
13988 
13989                                         
13990                                         
13991                                         
13992                                       } /*opt-block*//*opt-block+*/
13993                                       else 
13994                                         goto MATCH_label_a517;  /*opt-block+*/
13995                                       
13996                                       break;
13997                                     case 2: 
13998                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
13999                                       if ((MATCH_w_8_16 & 0x7) 
14000                                               /* r_m at 16 */ == 4 && 
14001                                         (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
14002                                               /* index at 24 */ && 
14003                                         (MATCH_w_8_24 >> 3 & 0x7) 
14004                                               /* index at 24 */ < 8)) 
14005                                         goto MATCH_label_a518;  /*opt-block+*/
14006                                       else 
14007                                         goto MATCH_label_a519;  /*opt-block+*/
14008                                       
14009                                       break;
14010                                     case 3: 
14011                                       goto MATCH_label_a516; break;
14012                                     default: assert(0);
14013                                   } /* (MATCH_w_8_16 >> 6 & 0x3) 
14014                                         -- mod at 16 --*/ 
14015                                 
14016                               } /*opt-block*/
14017                               break;
14018                             default: assert(0);
14019                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
14020                         break;
14021                       case 9: 
14022                         if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) 
14023                           
14024                             switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
14025                               case 0: 
14026                                 nextPC = 2 + MATCH_p; 
14027                                 
14028                                 #line 977 "machine/pentium/disassembler.m"
14029                                 
14030 
14031                                         sprintf (str,  "CBW");
14032 
14033                                 
14034 
14035                                     /* Decode the following as a NOP. We see these in startup code, and anywhere
14036 
14037                                         that calls the OS (as lcall 7, 0) */
14038 
14039                                 
14040                                 
14041                                 
14042                                 
14043                                 break;
14044                               case 1: 
14045                                 nextPC = 2 + MATCH_p; 
14046                                 
14047                                 #line 932 "machine/pentium/disassembler.m"
14048                                 
14049 
14050                                         sprintf (str,  "CWD");
14051 
14052                                 
14053 
14054                                 
14055                                 
14056                                 
14057                                 
14058                                 break;
14059                               case 2: case 3: case 6: case 7: 
14060                                 goto MATCH_label_a39; break;
14061                               case 4: 
14062                                 nextPC = 2 + MATCH_p; 
14063                                 
14064                                 #line 498 "machine/pentium/disassembler.m"
14065                                 
14066 
14067                                         sprintf (str,  "PUSHFow");
14068 
14069                                 
14070 
14071                                 //    | PUSHAod() =>
14072 
14073                                 //        sprintf (str,  "PUSHAod");
14074 
14075                                 
14076 
14077                                 //    | PUSHAow() =>
14078 
14079                                 //        sprintf (str,  "PUSHAow");
14080 
14081                                 
14082 
14083                                 
14084                                 
14085                                 
14086                                 
14087                                 break;
14088                               case 5: 
14089                                 nextPC = 2 + MATCH_p; 
14090                                 
14091                                 #line 552 "machine/pentium/disassembler.m"
14092                                 
14093 
14094                                         sprintf (str,  "POPFow");
14095 
14096                                 
14097 
14098                                 //    | POPAod() =>
14099 
14100                                 //        sprintf (str,  "POPAod");
14101 
14102                                 
14103 
14104                                 //    | POPAow() =>
14105 
14106                                 //        sprintf (str,  "POPAow");
14107 
14108                                 
14109 
14110                                 
14111                                 
14112                                 
14113                                 
14114                                 break;
14115                               default: assert(0);
14116                             } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/  
14117                         else { 
14118                           unsigned r32 = (MATCH_w_8_8 & 0x7) /* r32 at 8 */;
14119                           nextPC = 2 + MATCH_p; 
14120                           
14121                           #line 68 "machine/pentium/disassembler.m"
14122                           
14123 
14124                                   sprintf (str,  "XCHGeAXow", DIS_R32);
14125 
14126                           
14127 
14128                           
14129                           
14130                           
14131                         } /*opt-block*//*opt-block+*/
14132                         break;
14133                       case 10: 
14134                         
14135                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
14136                             case 0: case 2: case 4: case 6: 
14137                               goto MATCH_label_a39; break;
14138                             case 1: 
14139                               if ((MATCH_w_8_8 >> 3 & 0x1) 
14140                                       /* page at 8 */ == 1) { 
14141                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
14142                                 { 
14143                                   unsigned i16 = 
14144                                     (MATCH_w_16_16 & 0xffff) /* i16 at 16 */;
14145                                   nextPC = 4 + MATCH_p; 
14146                                   
14147                                   #line 116 "machine/pentium/disassembler.m"
14148                                   
14149 
14150                                           sprintf (str,  "TEST.eAX.Ivow", DIS_I16);
14151 
14152                                   
14153 
14154                                   
14155                                   
14156                                   
14157                                 }
14158                                 
14159                               } /*opt-block*/
14160                               else { 
14161                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
14162                                 { 
14163                                   unsigned off = 
14164                                     MATCH_w_32_16 /* i32 at 16 */;
14165                                   nextPC = 6 + MATCH_p; 
14166                                   
14167                                   #line 715 "machine/pentium/disassembler.m"
14168                                   
14169 
14170                                           sprintf (str,  "MOV.eAX.Ovow", DIS_OFF);
14171 
14172                                   
14173 
14174                                   
14175                                   
14176                                   
14177                                 }
14178                                 
14179                               } /*opt-block*/
14180                               
14181                               break;
14182                             case 3: 
14183                               if ((MATCH_w_8_8 >> 3 & 0x1) 
14184                                       /* page at 8 */ == 1) { 
14185                                 nextPC = 2 + MATCH_p; 
14186                                 
14187                                 #line 128 "machine/pentium/disassembler.m"
14188                                 
14189 
14190                                         sprintf (str,  "STOSvow");
14191 
14192                                 
14193 
14194                                 
14195                                 
14196                                 
14197                               } /*opt-block*//*opt-block+*/
14198                               else { 
14199                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
14200                                 { 
14201                                   unsigned off = 
14202                                     MATCH_w_32_16 /* i32 at 16 */;
14203                                   nextPC = 6 + MATCH_p; 
14204                                   
14205                                   #line 706 "machine/pentium/disassembler.m"
14206                                   
14207 
14208                                           sprintf (str,  "MOV.Ov.eAXow", DIS_OFF);
14209 
14210                                   
14211 
14212                                   
14213                                   
14214                                   
14215                                 }
14216                                 
14217                               } /*opt-block*/
14218                               
14219                               break;
14220                             case 5: 
14221                               if ((MATCH_w_8_8 >> 3 & 0x1) 
14222                                       /* page at 8 */ == 1) { 
14223                                 nextPC = 2 + MATCH_p; 
14224                                 
14225                                 #line 1417 "machine/pentium/disassembler.m"
14226                                 
14227 
14228                                         sprintf (str,  "LODSvow");
14229 
14230                                 
14231 
14232                                 
14233                                 
14234                                 
14235                               } /*opt-block*//*opt-block+*/
14236                               else { 
14237                                 nextPC = 2 + MATCH_p; 
14238                                 
14239                                 #line 663 "machine/pentium/disassembler.m"
14240                                 
14241 
14242                                         sprintf (str,  "MOVSvow");
14243 
14244                                 
14245 
14246                                 
14247                                 
14248                                 
14249                               } /*opt-block*//*opt-block+*/
14250                               
14251                               break;
14252                             case 7: 
14253                               if ((MATCH_w_8_8 >> 3 & 0x1) 
14254                                       /* page at 8 */ == 1) { 
14255                                 nextPC = 2 + MATCH_p; 
14256                                 
14257                                 #line 183 "machine/pentium/disassembler.m"
14258                                 
14259 
14260                                         sprintf (str,  "SCASvow");
14261 
14262                                 
14263 
14264                                 
14265                                 
14266                                 
14267                               } /*opt-block*//*opt-block+*/
14268                               else { 
14269                                 nextPC = 2 + MATCH_p; 
14270                                 
14271                                 #line 953 "machine/pentium/disassembler.m"
14272                                 
14273 
14274                                         sprintf (str,  "CMPSvow");
14275 
14276                                 
14277 
14278                                 
14279                                 
14280                                 
14281                               } /*opt-block*//*opt-block+*/
14282                               
14283                               break;
14284                             default: assert(0);
14285                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
14286                         break;
14287                       case 11: 
14288                         if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) { 
14289                           MATCH_w_16_16 = getWord(2 + MATCH_p); 
14290                           { 
14291                             int /* [~32768..32767] */ i16 = 
14292                               sign_extend(
14293                                           (MATCH_w_16_16 & 0xffff) 
14294                                                 /* i16 at 16 */, 16);
14295                             unsigned r16 = (MATCH_w_8_8 & 0x7) /* r16 at 8 */;
14296                             nextPC = 4 + MATCH_p; 
14297                             
14298                             #line 697 "machine/pentium/disassembler.m"
14299                             
14300 
14301                                     sprintf (str,  "MOViw", DIS_R16, DIS_I16);  // Check!
14302 
14303                             
14304 
14305                             
14306                             
14307                             
14308                           }
14309                           
14310                         } /*opt-block*/
14311                         else 
14312                           goto MATCH_label_a39;  /*opt-block+*/
14313                         
14314                         break;
14315                       case 12: 
14316                         
14317                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
14318                             case 0: case 2: case 3: case 4: case 5: case 6: 
14319                               goto MATCH_label_a39; break;
14320                             case 1: 
14321                               if ((MATCH_w_8_8 >> 3 & 0x1) 
14322                                       /* page at 8 */ == 1) 
14323                                 goto MATCH_label_a39;  /*opt-block+*/
14324                               else { 
14325                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
14326                                 
14327                                   switch((MATCH_w_8_16 >> 3 & 0x7) 
14328                                         /* reg_opcode at 16 */) {
14329                                     case 0: 
14330                                       
14331                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
14332                                               /* mod at 16 */) {
14333                                           case 0: 
14334                                             
14335                                               switch((MATCH_w_8_16 & 0x7) 
14336                                                     /* r_m at 16 */) {
14337                                                 case 0: case 1: case 2: 
14338                                                 case 3: case 6: case 7: 
14339                                                   MATCH_w_8_24 = 
14340                                                     getByte(3 + MATCH_p); 
14341                                                   goto MATCH_label_a523; 
14342                                                   
14343                                                   break;
14344                                                 case 4: 
14345                                                   MATCH_w_8_24 = 
14346                                                     getByte(3 + MATCH_p); 
14347                                                   if ((MATCH_w_8_24 & 0x7) 
14348                                                           /* base at 24 */ == 5 && 
14349                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
14350                                                           /* index at 24 */ && 
14351                                                     (MATCH_w_8_24 >> 3 & 0x7) 
14352                                                           /* index at 24 */ < 8)) { 
14353                                                     MATCH_w_8_64 = 
14354                                                       getByte(8 + MATCH_p); 
14355                                                     goto MATCH_label_a525; 
14356                                                     
14357                                                   } /*opt-block*/
14358                                                   else { 
14359                                                     MATCH_w_8_32 = 
14360                                                       getByte(4 + MATCH_p); 
14361                                                     goto MATCH_label_a524; 
14362                                                     
14363                                                   } /*opt-block*/
14364                                                   
14365                                                   break;
14366                                                 case 5: 
14367                                                   MATCH_w_8_56 = 
14368                                                     getByte(7 + MATCH_p); 
14369                                                   goto MATCH_label_a526; 
14370                                                   
14371                                                   break;
14372                                                 default: assert(0);
14373                                               } /* (MATCH_w_8_16 & 0x7) 
14374                                                     -- r_m at 16 --*/ 
14375                                             break;
14376                                           case 1: 
14377                                             MATCH_w_8_24 = 
14378                                               getByte(3 + MATCH_p); 
14379                                             if ((MATCH_w_8_16 & 0x7) 
14380                                                     /* r_m at 16 */ == 4 && 
14381                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
14382                                                     /* index at 24 */ && 
14383                                               (MATCH_w_8_24 >> 3 & 0x7) 
14384                                                     /* index at 24 */ < 8)) { 
14385                                               MATCH_w_8_40 = 
14386                                                 getByte(5 + MATCH_p); 
14387                                               { 
14388                                                 unsigned Eaddr = 
14389                                                   2 + addressToPC(MATCH_p);
14390                                                 int /* [~128..127] */ i8 = 
14391                                                   sign_extend(
14392                                                               (MATCH_w_8_40 & 0xff) 
14393                                                                     /* i8 at 40 */, 
14394                                                               8);
14395                                                 nextPC = 6 + MATCH_p; 
14396                                                 
14397                                                 #line 345 "machine/pentium/disassembler.m"
14398                                                 
14399 
14400                                                         sprintf (str,  "ROLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
14401 
14402                                                 
14403 
14404                                                 
14405                                                 
14406                                                 
14407                                               }
14408                                               
14409                                             } /*opt-block*/
14410                                             else { 
14411                                               MATCH_w_8_32 = 
14412                                                 getByte(4 + MATCH_p); 
14413                                               goto MATCH_label_a524; 
14414                                               
14415                                             } /*opt-block*/
14416                                             
14417                                             break;
14418                                           case 2: 
14419                                             MATCH_w_8_24 = 
14420                                               getByte(3 + MATCH_p); 
14421                                             if ((MATCH_w_8_16 & 0x7) 
14422                                                     /* r_m at 16 */ == 4 && 
14423                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
14424                                                     /* index at 24 */ && 
14425                                               (MATCH_w_8_24 >> 3 & 0x7) 
14426                                                     /* index at 24 */ < 8)) { 
14427                                               MATCH_w_8_64 = 
14428                                                 getByte(8 + MATCH_p); 
14429                                               goto MATCH_label_a525; 
14430                                               
14431                                             } /*opt-block*/
14432                                             else { 
14433                                               MATCH_w_8_56 = 
14434                                                 getByte(7 + MATCH_p); 
14435                                               goto MATCH_label_a526; 
14436                                               
14437                                             } /*opt-block*/
14438                                             
14439                                             break;
14440                                           case 3: 
14441                                             MATCH_w_8_24 = 
14442                                               getByte(3 + MATCH_p); 
14443                                             goto MATCH_label_a523; 
14444                                             
14445                                             break;
14446                                           default: assert(0);
14447                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
14448                                               -- mod at 16 --*/ 
14449                                       break;
14450                                     case 1: 
14451                                       
14452                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
14453                                               /* mod at 16 */) {
14454                                           case 0: 
14455                                             
14456                                               switch((MATCH_w_8_16 & 0x7) 
14457                                                     /* r_m at 16 */) {
14458                                                 case 0: case 1: case 2: 
14459                                                 case 3: case 6: case 7: 
14460                                                   MATCH_w_8_24 = 
14461                                                     getByte(3 + MATCH_p); 
14462                                                   goto MATCH_label_a527; 
14463                                                   
14464                                                   break;
14465                                                 case 4: 
14466                                                   MATCH_w_8_24 = 
14467                                                     getByte(3 + MATCH_p); 
14468                                                   if ((MATCH_w_8_24 & 0x7) 
14469                                                           /* base at 24 */ == 5 && 
14470                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
14471                                                           /* index at 24 */ && 
14472                                                     (MATCH_w_8_24 >> 3 & 0x7) 
14473                                                           /* index at 24 */ < 8)) { 
14474                                                     MATCH_w_8_64 = 
14475                                                       getByte(8 + MATCH_p); 
14476                                                     goto MATCH_label_a529; 
14477                                                     
14478                                                   } /*opt-block*/
14479                                                   else { 
14480                                                     MATCH_w_8_32 = 
14481                                                       getByte(4 + MATCH_p); 
14482                                                     goto MATCH_label_a528; 
14483                                                     
14484                                                   } /*opt-block*/
14485                                                   
14486                                                   break;
14487                                                 case 5: 
14488                                                   MATCH_w_8_56 = 
14489                                                     getByte(7 + MATCH_p); 
14490                                                   goto MATCH_label_a530; 
14491                                                   
14492                                                   break;
14493                                                 default: assert(0);
14494                                               } /* (MATCH_w_8_16 & 0x7) 
14495                                                     -- r_m at 16 --*/ 
14496                                             break;
14497                                           case 1: 
14498                                             MATCH_w_8_24 = 
14499                                               getByte(3 + MATCH_p); 
14500                                             if ((MATCH_w_8_16 & 0x7) 
14501                                                     /* r_m at 16 */ == 4 && 
14502                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
14503                                                     /* index at 24 */ && 
14504                                               (MATCH_w_8_24 >> 3 & 0x7) 
14505                                                     /* index at 24 */ < 8)) { 
14506                                               MATCH_w_8_40 = 
14507                                                 getByte(5 + MATCH_p); 
14508                                               { 
14509                                                 unsigned Eaddr = 
14510                                                   2 + addressToPC(MATCH_p);
14511                                                 int /* [~128..127] */ i8 = 
14512                                                   sign_extend(
14513                                                               (MATCH_w_8_40 & 0xff) 
14514                                                                     /* i8 at 40 */, 
14515                                                               8);
14516                                                 nextPC = 6 + MATCH_p; 
14517                                                 
14518                                                 #line 339 "machine/pentium/disassembler.m"
14519                                                 
14520 
14521                                                         sprintf (str,  "RORB.Ev.Ibow", DIS_EADDR16, DIS_I8);
14522 
14523                                                 
14524 
14525                                                 
14526                                                 
14527                                                 
14528                                               }
14529                                               
14530                                             } /*opt-block*/
14531                                             else { 
14532                                               MATCH_w_8_32 = 
14533                                                 getByte(4 + MATCH_p); 
14534                                               goto MATCH_label_a528; 
14535                                               
14536                                             } /*opt-block*/
14537                                             
14538                                             break;
14539                                           case 2: 
14540                                             MATCH_w_8_24 = 
14541                                               getByte(3 + MATCH_p); 
14542                                             if ((MATCH_w_8_16 & 0x7) 
14543                                                     /* r_m at 16 */ == 4 && 
14544                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
14545                                                     /* index at 24 */ && 
14546                                               (MATCH_w_8_24 >> 3 & 0x7) 
14547                                                     /* index at 24 */ < 8)) { 
14548                                               MATCH_w_8_64 = 
14549                                                 getByte(8 + MATCH_p); 
14550                                               goto MATCH_label_a529; 
14551                                               
14552                                             } /*opt-block*/
14553                                             else { 
14554                                               MATCH_w_8_56 = 
14555                                                 getByte(7 + MATCH_p); 
14556                                               goto MATCH_label_a530; 
14557                                               
14558                                             } /*opt-block*/
14559                                             
14560                                             break;
14561                                           case 3: 
14562                                             MATCH_w_8_24 = 
14563                                               getByte(3 + MATCH_p); 
14564                                             goto MATCH_label_a527; 
14565                                             
14566                                             break;
14567                                           default: assert(0);
14568                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
14569                                               -- mod at 16 --*/ 
14570                                       break;
14571                                     case 2: 
14572                                       
14573                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
14574                                               /* mod at 16 */) {
14575                                           case 0: 
14576                                             
14577                                               switch((MATCH_w_8_16 & 0x7) 
14578                                                     /* r_m at 16 */) {
14579                                                 case 0: case 1: case 2: 
14580                                                 case 3: case 6: case 7: 
14581                                                   MATCH_w_8_24 = 
14582                                                     getByte(3 + MATCH_p); 
14583                                                   goto MATCH_label_a531; 
14584                                                   
14585                                                   break;
14586                                                 case 4: 
14587                                                   MATCH_w_8_24 = 
14588                                                     getByte(3 + MATCH_p); 
14589                                                   if ((MATCH_w_8_24 & 0x7) 
14590                                                           /* base at 24 */ == 5 && 
14591                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
14592                                                           /* index at 24 */ && 
14593                                                     (MATCH_w_8_24 >> 3 & 0x7) 
14594                                                           /* index at 24 */ < 8)) { 
14595                                                     MATCH_w_8_64 = 
14596                                                       getByte(8 + MATCH_p); 
14597                                                     goto MATCH_label_a533; 
14598                                                     
14599                                                   } /*opt-block*/
14600                                                   else { 
14601                                                     MATCH_w_8_32 = 
14602                                                       getByte(4 + MATCH_p); 
14603                                                     goto MATCH_label_a532; 
14604                                                     
14605                                                   } /*opt-block*/
14606                                                   
14607                                                   break;
14608                                                 case 5: 
14609                                                   MATCH_w_8_56 = 
14610                                                     getByte(7 + MATCH_p); 
14611                                                   goto MATCH_label_a534; 
14612                                                   
14613                                                   break;
14614                                                 default: assert(0);
14615                                               } /* (MATCH_w_8_16 & 0x7) 
14616                                                     -- r_m at 16 --*/ 
14617                                             break;
14618                                           case 1: 
14619                                             MATCH_w_8_24 = 
14620                                               getByte(3 + MATCH_p); 
14621                                             if ((MATCH_w_8_16 & 0x7) 
14622                                                     /* r_m at 16 */ == 4 && 
14623                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
14624                                                     /* index at 24 */ && 
14625                                               (MATCH_w_8_24 >> 3 & 0x7) 
14626                                                     /* index at 24 */ < 8)) { 
14627                                               MATCH_w_8_40 = 
14628                                                 getByte(5 + MATCH_p); 
14629                                               { 
14630                                                 unsigned Eaddr = 
14631                                                   2 + addressToPC(MATCH_p);
14632                                                 int /* [~128..127] */ i8 = 
14633                                                   sign_extend(
14634                                                               (MATCH_w_8_40 & 0xff) 
14635                                                                     /* i8 at 40 */, 
14636                                                               8);
14637                                                 nextPC = 6 + MATCH_p; 
14638                                                 
14639                                                 #line 333 "machine/pentium/disassembler.m"
14640                                                 
14641 
14642                                                         sprintf (str,  "RCLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
14643 
14644                                                 
14645 
14646                                                 
14647                                                 
14648                                                 
14649                                               }
14650                                               
14651                                             } /*opt-block*/
14652                                             else { 
14653                                               MATCH_w_8_32 = 
14654                                                 getByte(4 + MATCH_p); 
14655                                               goto MATCH_label_a532; 
14656                                               
14657                                             } /*opt-block*/
14658                                             
14659                                             break;
14660                                           case 2: 
14661                                             MATCH_w_8_24 = 
14662                                               getByte(3 + MATCH_p); 
14663                                             if ((MATCH_w_8_16 & 0x7) 
14664                                                     /* r_m at 16 */ == 4 && 
14665                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
14666                                                     /* index at 24 */ && 
14667                                               (MATCH_w_8_24 >> 3 & 0x7) 
14668                                                     /* index at 24 */ < 8)) { 
14669                                               MATCH_w_8_64 = 
14670                                                 getByte(8 + MATCH_p); 
14671                                               goto MATCH_label_a533; 
14672                                               
14673                                             } /*opt-block*/
14674                                             else { 
14675                                               MATCH_w_8_56 = 
14676                                                 getByte(7 + MATCH_p); 
14677                                               goto MATCH_label_a534; 
14678                                               
14679                                             } /*opt-block*/
14680                                             
14681                                             break;
14682                                           case 3: 
14683                                             MATCH_w_8_24 = 
14684                                               getByte(3 + MATCH_p); 
14685                                             goto MATCH_label_a531; 
14686                                             
14687                                             break;
14688                                           default: assert(0);
14689                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
14690                                               -- mod at 16 --*/ 
14691                                       break;
14692                                     case 3: 
14693                                       
14694                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
14695                                               /* mod at 16 */) {
14696                                           case 0: 
14697                                             
14698                                               switch((MATCH_w_8_16 & 0x7) 
14699                                                     /* r_m at 16 */) {
14700                                                 case 0: case 1: case 2: 
14701                                                 case 3: case 6: case 7: 
14702                                                   MATCH_w_8_24 = 
14703                                                     getByte(3 + MATCH_p); 
14704                                                   goto MATCH_label_a535; 
14705                                                   
14706                                                   break;
14707                                                 case 4: 
14708                                                   MATCH_w_8_24 = 
14709                                                     getByte(3 + MATCH_p); 
14710                                                   if ((MATCH_w_8_24 & 0x7) 
14711                                                           /* base at 24 */ == 5 && 
14712                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
14713                                                           /* index at 24 */ && 
14714                                                     (MATCH_w_8_24 >> 3 & 0x7) 
14715                                                           /* index at 24 */ < 8)) { 
14716                                                     MATCH_w_8_64 = 
14717                                                       getByte(8 + MATCH_p); 
14718                                                     goto MATCH_label_a537; 
14719                                                     
14720                                                   } /*opt-block*/
14721                                                   else { 
14722                                                     MATCH_w_8_32 = 
14723                                                       getByte(4 + MATCH_p); 
14724                                                     goto MATCH_label_a536; 
14725                                                     
14726                                                   } /*opt-block*/
14727                                                   
14728                                                   break;
14729                                                 case 5: 
14730                                                   MATCH_w_8_56 = 
14731                                                     getByte(7 + MATCH_p); 
14732                                                   goto MATCH_label_a538; 
14733                                                   
14734                                                   break;
14735                                                 default: assert(0);
14736                                               } /* (MATCH_w_8_16 & 0x7) 
14737                                                     -- r_m at 16 --*/ 
14738                                             break;
14739                                           case 1: 
14740                                             MATCH_w_8_24 = 
14741                                               getByte(3 + MATCH_p); 
14742                                             if ((MATCH_w_8_16 & 0x7) 
14743                                                     /* r_m at 16 */ == 4 && 
14744                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
14745                                                     /* index at 24 */ && 
14746                                               (MATCH_w_8_24 >> 3 & 0x7) 
14747                                                     /* index at 24 */ < 8)) { 
14748                                               MATCH_w_8_40 = 
14749                                                 getByte(5 + MATCH_p); 
14750                                               { 
14751                                                 unsigned Eaddr = 
14752                                                   2 + addressToPC(MATCH_p);
14753                                                 int /* [~128..127] */ i8 = 
14754                                                   sign_extend(
14755                                                               (MATCH_w_8_40 & 0xff) 
14756                                                                     /* i8 at 40 */, 
14757                                                               8);
14758                                                 nextPC = 6 + MATCH_p; 
14759                                                 
14760                                                 #line 327 "machine/pentium/disassembler.m"
14761                                                 
14762 
14763                                                         sprintf (str,  "RCRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
14764 
14765                                                 
14766 
14767                                                 
14768                                                 
14769                                                 
14770                                               }
14771                                               
14772                                             } /*opt-block*/
14773                                             else { 
14774                                               MATCH_w_8_32 = 
14775                                                 getByte(4 + MATCH_p); 
14776                                               goto MATCH_label_a536; 
14777                                               
14778                                             } /*opt-block*/
14779                                             
14780                                             break;
14781                                           case 2: 
14782                                             MATCH_w_8_24 = 
14783                                               getByte(3 + MATCH_p); 
14784                                             if ((MATCH_w_8_16 & 0x7) 
14785                                                     /* r_m at 16 */ == 4 && 
14786                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
14787                                                     /* index at 24 */ && 
14788                                               (MATCH_w_8_24 >> 3 & 0x7) 
14789                                                     /* index at 24 */ < 8)) { 
14790                                               MATCH_w_8_64 = 
14791                                                 getByte(8 + MATCH_p); 
14792                                               goto MATCH_label_a537; 
14793                                               
14794                                             } /*opt-block*/
14795                                             else { 
14796                                               MATCH_w_8_56 = 
14797                                                 getByte(7 + MATCH_p); 
14798                                               goto MATCH_label_a538; 
14799                                               
14800                                             } /*opt-block*/
14801                                             
14802                                             break;
14803                                           case 3: 
14804                                             MATCH_w_8_24 = 
14805                                               getByte(3 + MATCH_p); 
14806                                             goto MATCH_label_a535; 
14807                                             
14808                                             break;
14809                                           default: assert(0);
14810                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
14811                                               -- mod at 16 --*/ 
14812                                       break;
14813                                     case 4: 
14814                                       
14815                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
14816                                               /* mod at 16 */) {
14817                                           case 0: 
14818                                             
14819                                               switch((MATCH_w_8_16 & 0x7) 
14820                                                     /* r_m at 16 */) {
14821                                                 case 0: case 1: case 2: 
14822                                                 case 3: case 6: case 7: 
14823                                                   MATCH_w_8_24 = 
14824                                                     getByte(3 + MATCH_p); 
14825                                                   goto MATCH_label_a539; 
14826                                                   
14827                                                   break;
14828                                                 case 4: 
14829                                                   MATCH_w_8_24 = 
14830                                                     getByte(3 + MATCH_p); 
14831                                                   if ((MATCH_w_8_24 & 0x7) 
14832                                                           /* base at 24 */ == 5 && 
14833                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
14834                                                           /* index at 24 */ && 
14835                                                     (MATCH_w_8_24 >> 3 & 0x7) 
14836                                                           /* index at 24 */ < 8)) { 
14837                                                     MATCH_w_8_64 = 
14838                                                       getByte(8 + MATCH_p); 
14839                                                     goto MATCH_label_a541; 
14840                                                     
14841                                                   } /*opt-block*/
14842                                                   else { 
14843                                                     MATCH_w_8_32 = 
14844                                                       getByte(4 + MATCH_p); 
14845                                                     goto MATCH_label_a540; 
14846                                                     
14847                                                   } /*opt-block*/
14848                                                   
14849                                                   break;
14850                                                 case 5: 
14851                                                   MATCH_w_8_56 = 
14852                                                     getByte(7 + MATCH_p); 
14853                                                   goto MATCH_label_a542; 
14854                                                   
14855                                                   break;
14856                                                 default: assert(0);
14857                                               } /* (MATCH_w_8_16 & 0x7) 
14858                                                     -- r_m at 16 --*/ 
14859                                             break;
14860                                           case 1: 
14861                                             MATCH_w_8_24 = 
14862                                               getByte(3 + MATCH_p); 
14863                                             if ((MATCH_w_8_16 & 0x7) 
14864                                                     /* r_m at 16 */ == 4 && 
14865                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
14866                                                     /* index at 24 */ && 
14867                                               (MATCH_w_8_24 >> 3 & 0x7) 
14868                                                     /* index at 24 */ < 8)) { 
14869                                               MATCH_w_8_40 = 
14870                                                 getByte(5 + MATCH_p); 
14871                                               { 
14872                                                 unsigned Eaddr = 
14873                                                   2 + addressToPC(MATCH_p);
14874                                                 int /* [~128..127] */ i8 = 
14875                                                   sign_extend(
14876                                                               (MATCH_w_8_40 & 0xff) 
14877                                                                     /* i8 at 40 */, 
14878                                                               8);
14879                                                 nextPC = 6 + MATCH_p; 
14880                                                 
14881                                                 #line 321 "machine/pentium/disassembler.m"
14882                                                 
14883 
14884                                                         sprintf (str,  "SHLSALB.Ev.Ibow", DIS_EADDR16, DIS_I8);
14885 
14886                                                 
14887 
14888                                                 
14889                                                 
14890                                                 
14891                                               }
14892                                               
14893                                             } /*opt-block*/
14894                                             else { 
14895                                               MATCH_w_8_32 = 
14896                                                 getByte(4 + MATCH_p); 
14897                                               goto MATCH_label_a540; 
14898                                               
14899                                             } /*opt-block*/
14900                                             
14901                                             break;
14902                                           case 2: 
14903                                             MATCH_w_8_24 = 
14904                                               getByte(3 + MATCH_p); 
14905                                             if ((MATCH_w_8_16 & 0x7) 
14906                                                     /* r_m at 16 */ == 4 && 
14907                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
14908                                                     /* index at 24 */ && 
14909                                               (MATCH_w_8_24 >> 3 & 0x7) 
14910                                                     /* index at 24 */ < 8)) { 
14911                                               MATCH_w_8_64 = 
14912                                                 getByte(8 + MATCH_p); 
14913                                               goto MATCH_label_a541; 
14914                                               
14915                                             } /*opt-block*/
14916                                             else { 
14917                                               MATCH_w_8_56 = 
14918                                                 getByte(7 + MATCH_p); 
14919                                               goto MATCH_label_a542; 
14920                                               
14921                                             } /*opt-block*/
14922                                             
14923                                             break;
14924                                           case 3: 
14925                                             MATCH_w_8_24 = 
14926                                               getByte(3 + MATCH_p); 
14927                                             goto MATCH_label_a539; 
14928                                             
14929                                             break;
14930                                           default: assert(0);
14931                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
14932                                               -- mod at 16 --*/ 
14933                                       break;
14934                                     case 5: 
14935                                       
14936                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
14937                                               /* mod at 16 */) {
14938                                           case 0: 
14939                                             
14940                                               switch((MATCH_w_8_16 & 0x7) 
14941                                                     /* r_m at 16 */) {
14942                                                 case 0: case 1: case 2: 
14943                                                 case 3: case 6: case 7: 
14944                                                   MATCH_w_8_24 = 
14945                                                     getByte(3 + MATCH_p); 
14946                                                   goto MATCH_label_a543; 
14947                                                   
14948                                                   break;
14949                                                 case 4: 
14950                                                   MATCH_w_8_24 = 
14951                                                     getByte(3 + MATCH_p); 
14952                                                   if ((MATCH_w_8_24 & 0x7) 
14953                                                           /* base at 24 */ == 5 && 
14954                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
14955                                                           /* index at 24 */ && 
14956                                                     (MATCH_w_8_24 >> 3 & 0x7) 
14957                                                           /* index at 24 */ < 8)) { 
14958                                                     MATCH_w_8_64 = 
14959                                                       getByte(8 + MATCH_p); 
14960                                                     goto MATCH_label_a545; 
14961                                                     
14962                                                   } /*opt-block*/
14963                                                   else { 
14964                                                     MATCH_w_8_32 = 
14965                                                       getByte(4 + MATCH_p); 
14966                                                     goto MATCH_label_a544; 
14967                                                     
14968                                                   } /*opt-block*/
14969                                                   
14970                                                   break;
14971                                                 case 5: 
14972                                                   MATCH_w_8_56 = 
14973                                                     getByte(7 + MATCH_p); 
14974                                                   goto MATCH_label_a546; 
14975                                                   
14976                                                   break;
14977                                                 default: assert(0);
14978                                               } /* (MATCH_w_8_16 & 0x7) 
14979                                                     -- r_m at 16 --*/ 
14980                                             break;
14981                                           case 1: 
14982                                             MATCH_w_8_24 = 
14983                                               getByte(3 + MATCH_p); 
14984                                             if ((MATCH_w_8_16 & 0x7) 
14985                                                     /* r_m at 16 */ == 4 && 
14986                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
14987                                                     /* index at 24 */ && 
14988                                               (MATCH_w_8_24 >> 3 & 0x7) 
14989                                                     /* index at 24 */ < 8)) { 
14990                                               MATCH_w_8_40 = 
14991                                                 getByte(5 + MATCH_p); 
14992                                               { 
14993                                                 unsigned Eaddr = 
14994                                                   2 + addressToPC(MATCH_p);
14995                                                 int /* [~128..127] */ i8 = 
14996                                                   sign_extend(
14997                                                               (MATCH_w_8_40 & 0xff) 
14998                                                                     /* i8 at 40 */, 
14999                                                               8);
15000                                                 nextPC = 6 + MATCH_p; 
15001                                                 
15002                                                 #line 315 "machine/pentium/disassembler.m"
15003                                                 
15004 
15005                                                         sprintf (str,  "SHRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
15006 
15007                                                 
15008 
15009                                                 
15010                                                 
15011                                                 
15012                                               }
15013                                               
15014                                             } /*opt-block*/
15015                                             else { 
15016                                               MATCH_w_8_32 = 
15017                                                 getByte(4 + MATCH_p); 
15018                                               goto MATCH_label_a544; 
15019                                               
15020                                             } /*opt-block*/
15021                                             
15022                                             break;
15023                                           case 2: 
15024                                             MATCH_w_8_24 = 
15025                                               getByte(3 + MATCH_p); 
15026                                             if ((MATCH_w_8_16 & 0x7) 
15027                                                     /* r_m at 16 */ == 4 && 
15028                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15029                                                     /* index at 24 */ && 
15030                                               (MATCH_w_8_24 >> 3 & 0x7) 
15031                                                     /* index at 24 */ < 8)) { 
15032                                               MATCH_w_8_64 = 
15033                                                 getByte(8 + MATCH_p); 
15034                                               goto MATCH_label_a545; 
15035                                               
15036                                             } /*opt-block*/
15037                                             else { 
15038                                               MATCH_w_8_56 = 
15039                                                 getByte(7 + MATCH_p); 
15040                                               goto MATCH_label_a546; 
15041                                               
15042                                             } /*opt-block*/
15043                                             
15044                                             break;
15045                                           case 3: 
15046                                             MATCH_w_8_24 = 
15047                                               getByte(3 + MATCH_p); 
15048                                             goto MATCH_label_a543; 
15049                                             
15050                                             break;
15051                                           default: assert(0);
15052                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
15053                                               -- mod at 16 --*/ 
15054                                       break;
15055                                     case 6: 
15056                                       goto MATCH_label_a39; break;
15057                                     case 7: 
15058                                       
15059                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
15060                                               /* mod at 16 */) {
15061                                           case 0: 
15062                                             
15063                                               switch((MATCH_w_8_16 & 0x7) 
15064                                                     /* r_m at 16 */) {
15065                                                 case 0: case 1: case 2: 
15066                                                 case 3: case 6: case 7: 
15067                                                   MATCH_w_8_24 = 
15068                                                     getByte(3 + MATCH_p); 
15069                                                   goto MATCH_label_a547; 
15070                                                   
15071                                                   break;
15072                                                 case 4: 
15073                                                   MATCH_w_8_24 = 
15074                                                     getByte(3 + MATCH_p); 
15075                                                   if ((MATCH_w_8_24 & 0x7) 
15076                                                           /* base at 24 */ == 5 && 
15077                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15078                                                           /* index at 24 */ && 
15079                                                     (MATCH_w_8_24 >> 3 & 0x7) 
15080                                                           /* index at 24 */ < 8)) { 
15081                                                     MATCH_w_8_64 = 
15082                                                       getByte(8 + MATCH_p); 
15083                                                     goto MATCH_label_a549; 
15084                                                     
15085                                                   } /*opt-block*/
15086                                                   else { 
15087                                                     MATCH_w_8_32 = 
15088                                                       getByte(4 + MATCH_p); 
15089                                                     goto MATCH_label_a548; 
15090                                                     
15091                                                   } /*opt-block*/
15092                                                   
15093                                                   break;
15094                                                 case 5: 
15095                                                   MATCH_w_8_56 = 
15096                                                     getByte(7 + MATCH_p); 
15097                                                   goto MATCH_label_a550; 
15098                                                   
15099                                                   break;
15100                                                 default: assert(0);
15101                                               } /* (MATCH_w_8_16 & 0x7) 
15102                                                     -- r_m at 16 --*/ 
15103                                             break;
15104                                           case 1: 
15105                                             MATCH_w_8_24 = 
15106                                               getByte(3 + MATCH_p); 
15107                                             if ((MATCH_w_8_16 & 0x7) 
15108                                                     /* r_m at 16 */ == 4 && 
15109                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15110                                                     /* index at 24 */ && 
15111                                               (MATCH_w_8_24 >> 3 & 0x7) 
15112                                                     /* index at 24 */ < 8)) { 
15113                                               MATCH_w_8_40 = 
15114                                                 getByte(5 + MATCH_p); 
15115                                               { 
15116                                                 unsigned Eaddr = 
15117                                                   2 + addressToPC(MATCH_p);
15118                                                 int /* [~128..127] */ i8 = 
15119                                                   sign_extend(
15120                                                               (MATCH_w_8_40 & 0xff) 
15121                                                                     /* i8 at 40 */, 
15122                                                               8);
15123                                                 nextPC = 6 + MATCH_p; 
15124                                                 
15125                                                 #line 309 "machine/pentium/disassembler.m"
15126                                                 
15127 
15128                                                         sprintf (str,  "SARB.Ev.Ibow", DIS_EADDR16, DIS_I8);
15129 
15130                                                 
15131 
15132                                                 
15133                                                 
15134                                                 
15135                                               }
15136                                               
15137                                             } /*opt-block*/
15138                                             else { 
15139                                               MATCH_w_8_32 = 
15140                                                 getByte(4 + MATCH_p); 
15141                                               goto MATCH_label_a548; 
15142                                               
15143                                             } /*opt-block*/
15144                                             
15145                                             break;
15146                                           case 2: 
15147                                             MATCH_w_8_24 = 
15148                                               getByte(3 + MATCH_p); 
15149                                             if ((MATCH_w_8_16 & 0x7) 
15150                                                     /* r_m at 16 */ == 4 && 
15151                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15152                                                     /* index at 24 */ && 
15153                                               (MATCH_w_8_24 >> 3 & 0x7) 
15154                                                     /* index at 24 */ < 8)) { 
15155                                               MATCH_w_8_64 = 
15156                                                 getByte(8 + MATCH_p); 
15157                                               goto MATCH_label_a549; 
15158                                               
15159                                             } /*opt-block*/
15160                                             else { 
15161                                               MATCH_w_8_56 = 
15162                                                 getByte(7 + MATCH_p); 
15163                                               goto MATCH_label_a550; 
15164                                               
15165                                             } /*opt-block*/
15166                                             
15167                                             break;
15168                                           case 3: 
15169                                             MATCH_w_8_24 = 
15170                                               getByte(3 + MATCH_p); 
15171                                             goto MATCH_label_a547; 
15172                                             
15173                                             break;
15174                                           default: assert(0);
15175                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
15176                                               -- mod at 16 --*/ 
15177                                       break;
15178                                     default: assert(0);
15179                                   } /* (MATCH_w_8_16 >> 3 & 0x7) 
15180                                         -- reg_opcode at 16 --*/ 
15181                                 
15182                               } /*opt-block*/
15183                               break;
15184                             case 7: 
15185                               if ((MATCH_w_8_8 >> 3 & 0x1) 
15186                                       /* page at 8 */ == 1) 
15187                                 goto MATCH_label_a39;  /*opt-block+*/
15188                               else { 
15189                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
15190                                 if ((MATCH_w_8_16 >> 3 & 0x7) 
15191                                         /* reg_opcode at 16 */ == 0) 
15192                                   
15193                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
15194                                           /* mod at 16 */) {
15195                                       case 0: 
15196                                         
15197                                           switch((MATCH_w_8_16 & 0x7) 
15198                                                 /* r_m at 16 */) {
15199                                             case 0: case 1: case 2: case 3: 
15200                                             case 6: case 7: 
15201                                               MATCH_w_16_24 = 
15202                                                 getWord(3 + MATCH_p); 
15203                                               goto MATCH_label_a551; 
15204                                               
15205                                               break;
15206                                             case 4: 
15207                                               MATCH_w_8_24 = 
15208                                                 getByte(3 + MATCH_p); 
15209                                               if ((MATCH_w_8_24 & 0x7) 
15210                                                       /* base at 24 */ == 5 && 
15211                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15212                                                       /* index at 24 */ && 
15213                                                 (MATCH_w_8_24 >> 3 & 0x7) 
15214                                                       /* index at 24 */ < 8)) { 
15215                                                 MATCH_w_16_64 = 
15216                                                   getWord(8 + MATCH_p); 
15217                                                 goto MATCH_label_a553; 
15218                                                 
15219                                               } /*opt-block*/
15220                                               else { 
15221                                                 MATCH_w_16_32 = 
15222                                                   getWord(4 + MATCH_p); 
15223                                                 goto MATCH_label_a552; 
15224                                                 
15225                                               } /*opt-block*/
15226                                               
15227                                               break;
15228                                             case 5: 
15229                                               MATCH_w_16_56 = 
15230                                                 getWord(7 + MATCH_p); 
15231                                               goto MATCH_label_a554; 
15232                                               
15233                                               break;
15234                                             default: assert(0);
15235                                           } /* (MATCH_w_8_16 & 0x7) 
15236                                                 -- r_m at 16 --*/ 
15237                                         break;
15238                                       case 1: 
15239                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
15240                                         if ((MATCH_w_8_16 & 0x7) 
15241                                                 /* r_m at 16 */ == 4 && 
15242                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15243                                                 /* index at 24 */ && 
15244                                           (MATCH_w_8_24 >> 3 & 0x7) 
15245                                                 /* index at 24 */ < 8)) { 
15246                                           MATCH_w_16_40 = 
15247                                             getWord(5 + MATCH_p); 
15248                                           { 
15249                                             unsigned Eaddr = 
15250                                               2 + addressToPC(MATCH_p);
15251                                             int /* [~32768..32767] */ i16 = 
15252                                               sign_extend(
15253                                                           (MATCH_w_16_40 & 0xffff) 
15254                                                                 /* i16 at 40 */, 
15255                                                           16);
15256                                             nextPC = 7 + MATCH_p; 
15257                                             
15258                                             #line 688 "machine/pentium/disassembler.m"
15259                                             
15260 
15261                                                     sprintf (str,  "MOV.Eb.Ivow", DIS_EADDR16, DIS_I16);
15262 
15263                                             
15264 
15265                                             
15266                                             
15267                                             
15268                                           }
15269                                           
15270                                         } /*opt-block*/
15271                                         else { 
15272                                           MATCH_w_16_32 = 
15273                                             getWord(4 + MATCH_p); 
15274                                           goto MATCH_label_a552; 
15275                                           
15276                                         } /*opt-block*/
15277                                         
15278                                         break;
15279                                       case 2: 
15280                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
15281                                         if ((MATCH_w_8_16 & 0x7) 
15282                                                 /* r_m at 16 */ == 4 && 
15283                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15284                                                 /* index at 24 */ && 
15285                                           (MATCH_w_8_24 >> 3 & 0x7) 
15286                                                 /* index at 24 */ < 8)) { 
15287                                           MATCH_w_16_64 = 
15288                                             getWord(8 + MATCH_p); 
15289                                           goto MATCH_label_a553; 
15290                                           
15291                                         } /*opt-block*/
15292                                         else { 
15293                                           MATCH_w_16_56 = 
15294                                             getWord(7 + MATCH_p); 
15295                                           goto MATCH_label_a554; 
15296                                           
15297                                         } /*opt-block*/
15298                                         
15299                                         break;
15300                                       case 3: 
15301                                         MATCH_w_16_24 = getWord(3 + MATCH_p); 
15302                                         goto MATCH_label_a551; 
15303                                         
15304                                         break;
15305                                       default: assert(0);
15306                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
15307                                           -- mod at 16 --*/  
15308                                 else 
15309                                   goto MATCH_label_a39;  /*opt-block+*/
15310                                 
15311                               } /*opt-block*/
15312                               break;
15313                             default: assert(0);
15314                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
15315                         break;
15316                       case 13: 
15317                         
15318                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
15319                             case 0: case 2: case 4: case 5: case 6: case 7: 
15320                               goto MATCH_label_a39; break;
15321                             case 1: 
15322                               if ((MATCH_w_8_8 >> 3 & 0x1) 
15323                                       /* page at 8 */ == 1) 
15324                                 goto MATCH_label_a39;  /*opt-block+*/
15325                               else { 
15326                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
15327                                 
15328                                   switch((MATCH_w_8_16 >> 3 & 0x7) 
15329                                         /* reg_opcode at 16 */) {
15330                                     case 0: 
15331                                       
15332                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
15333                                               /* mod at 16 */) {
15334                                           case 0: 
15335                                             
15336                                               switch((MATCH_w_8_16 & 0x7) 
15337                                                     /* r_m at 16 */) {
15338                                                 case 0: case 1: case 2: 
15339                                                 case 3: case 6: case 7: 
15340                                                   goto MATCH_label_a555; 
15341                                                   
15342                                                   break;
15343                                                 case 4: 
15344                                                   MATCH_w_8_24 = 
15345                                                     getByte(3 + MATCH_p); 
15346                                                   if ((MATCH_w_8_24 & 0x7) 
15347                                                           /* base at 24 */ == 5 && 
15348                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15349                                                           /* index at 24 */ && 
15350                                                     (MATCH_w_8_24 >> 3 & 0x7) 
15351                                                           /* index at 24 */ < 8)) 
15352                                                     goto MATCH_label_a557;  /*opt-block+*/
15353                                                   else 
15354                                                     goto MATCH_label_a556;  /*opt-block+*/
15355                                                   
15356                                                   break;
15357                                                 case 5: 
15358                                                   goto MATCH_label_a558; 
15359                                                   
15360                                                   break;
15361                                                 default: assert(0);
15362                                               } /* (MATCH_w_8_16 & 0x7) 
15363                                                     -- r_m at 16 --*/ 
15364                                             break;
15365                                           case 1: 
15366                                             MATCH_w_8_24 = 
15367                                               getByte(3 + MATCH_p); 
15368                                             if ((MATCH_w_8_16 & 0x7) 
15369                                                     /* r_m at 16 */ == 4 && 
15370                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15371                                                     /* index at 24 */ && 
15372                                               (MATCH_w_8_24 >> 3 & 0x7) 
15373                                                     /* index at 24 */ < 8)) { 
15374                                               unsigned Eaddr = 
15375                                                 2 + addressToPC(MATCH_p);
15376                                               nextPC = 5 + MATCH_p; 
15377                                               
15378                                               #line 450 "machine/pentium/disassembler.m"
15379                                               
15380 
15381                                                       sprintf (str,  "ROLB.Ev.1ow", DIS_EADDR16);
15382 
15383                                               
15384 
15385                                               
15386                                               
15387                                               
15388                                             } /*opt-block*//*opt-block+*/
15389                                             else 
15390                                               goto MATCH_label_a556;  /*opt-block+*/
15391                                             
15392                                             break;
15393                                           case 2: 
15394                                             MATCH_w_8_24 = 
15395                                               getByte(3 + MATCH_p); 
15396                                             if ((MATCH_w_8_16 & 0x7) 
15397                                                     /* r_m at 16 */ == 4 && 
15398                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15399                                                     /* index at 24 */ && 
15400                                               (MATCH_w_8_24 >> 3 & 0x7) 
15401                                                     /* index at 24 */ < 8)) 
15402                                               goto MATCH_label_a557;  /*opt-block+*/
15403                                             else 
15404                                               goto MATCH_label_a558;  /*opt-block+*/
15405                                             
15406                                             break;
15407                                           case 3: 
15408                                             goto MATCH_label_a555; break;
15409                                           default: assert(0);
15410                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
15411                                               -- mod at 16 --*/ 
15412                                       break;
15413                                     case 1: 
15414                                       
15415                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
15416                                               /* mod at 16 */) {
15417                                           case 0: 
15418                                             
15419                                               switch((MATCH_w_8_16 & 0x7) 
15420                                                     /* r_m at 16 */) {
15421                                                 case 0: case 1: case 2: 
15422                                                 case 3: case 6: case 7: 
15423                                                   goto MATCH_label_a559; 
15424                                                   
15425                                                   break;
15426                                                 case 4: 
15427                                                   MATCH_w_8_24 = 
15428                                                     getByte(3 + MATCH_p); 
15429                                                   if ((MATCH_w_8_24 & 0x7) 
15430                                                           /* base at 24 */ == 5 && 
15431                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15432                                                           /* index at 24 */ && 
15433                                                     (MATCH_w_8_24 >> 3 & 0x7) 
15434                                                           /* index at 24 */ < 8)) 
15435                                                     goto MATCH_label_a561;  /*opt-block+*/
15436                                                   else 
15437                                                     goto MATCH_label_a560;  /*opt-block+*/
15438                                                   
15439                                                   break;
15440                                                 case 5: 
15441                                                   goto MATCH_label_a562; 
15442                                                   
15443                                                   break;
15444                                                 default: assert(0);
15445                                               } /* (MATCH_w_8_16 & 0x7) 
15446                                                     -- r_m at 16 --*/ 
15447                                             break;
15448                                           case 1: 
15449                                             MATCH_w_8_24 = 
15450                                               getByte(3 + MATCH_p); 
15451                                             if ((MATCH_w_8_16 & 0x7) 
15452                                                     /* r_m at 16 */ == 4 && 
15453                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15454                                                     /* index at 24 */ && 
15455                                               (MATCH_w_8_24 >> 3 & 0x7) 
15456                                                     /* index at 24 */ < 8)) { 
15457                                               unsigned Eaddr = 
15458                                                 2 + addressToPC(MATCH_p);
15459                                               nextPC = 5 + MATCH_p; 
15460                                               
15461                                               #line 438 "machine/pentium/disassembler.m"
15462                                               
15463 
15464                                                       sprintf (str,  "ORB.Ev.1owR", DIS_EADDR16);
15465 
15466                                               
15467 
15468                                               
15469                                               
15470                                               
15471                                             } /*opt-block*//*opt-block+*/
15472                                             else 
15473                                               goto MATCH_label_a560;  /*opt-block+*/
15474                                             
15475                                             break;
15476                                           case 2: 
15477                                             MATCH_w_8_24 = 
15478                                               getByte(3 + MATCH_p); 
15479                                             if ((MATCH_w_8_16 & 0x7) 
15480                                                     /* r_m at 16 */ == 4 && 
15481                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15482                                                     /* index at 24 */ && 
15483                                               (MATCH_w_8_24 >> 3 & 0x7) 
15484                                                     /* index at 24 */ < 8)) 
15485                                               goto MATCH_label_a561;  /*opt-block+*/
15486                                             else 
15487                                               goto MATCH_label_a562;  /*opt-block+*/
15488                                             
15489                                             break;
15490                                           case 3: 
15491                                             goto MATCH_label_a559; break;
15492                                           default: assert(0);
15493                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
15494                                               -- mod at 16 --*/ 
15495                                       break;
15496                                     case 2: 
15497                                       
15498                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
15499                                               /* mod at 16 */) {
15500                                           case 0: 
15501                                             
15502                                               switch((MATCH_w_8_16 & 0x7) 
15503                                                     /* r_m at 16 */) {
15504                                                 case 0: case 1: case 2: 
15505                                                 case 3: case 6: case 7: 
15506                                                   goto MATCH_label_a563; 
15507                                                   
15508                                                   break;
15509                                                 case 4: 
15510                                                   MATCH_w_8_24 = 
15511                                                     getByte(3 + MATCH_p); 
15512                                                   if ((MATCH_w_8_24 & 0x7) 
15513                                                           /* base at 24 */ == 5 && 
15514                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15515                                                           /* index at 24 */ && 
15516                                                     (MATCH_w_8_24 >> 3 & 0x7) 
15517                                                           /* index at 24 */ < 8)) 
15518                                                     goto MATCH_label_a565;  /*opt-block+*/
15519                                                   else 
15520                                                     goto MATCH_label_a564;  /*opt-block+*/
15521                                                   
15522                                                   break;
15523                                                 case 5: 
15524                                                   goto MATCH_label_a566; 
15525                                                   
15526                                                   break;
15527                                                 default: assert(0);
15528                                               } /* (MATCH_w_8_16 & 0x7) 
15529                                                     -- r_m at 16 --*/ 
15530                                             break;
15531                                           case 1: 
15532                                             MATCH_w_8_24 = 
15533                                               getByte(3 + MATCH_p); 
15534                                             if ((MATCH_w_8_16 & 0x7) 
15535                                                     /* r_m at 16 */ == 4 && 
15536                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15537                                                     /* index at 24 */ && 
15538                                               (MATCH_w_8_24 >> 3 & 0x7) 
15539                                                     /* index at 24 */ < 8)) { 
15540                                               unsigned Eaddr = 
15541                                                 2 + addressToPC(MATCH_p);
15542                                               nextPC = 5 + MATCH_p; 
15543                                               
15544                                               #line 426 "machine/pentium/disassembler.m"
15545                                               
15546 
15547                                                       sprintf (str,  "RCLB.Ev.1ow", DIS_EADDR16);
15548 
15549                                               
15550 
15551                                               
15552                                               
15553                                               
15554                                             } /*opt-block*//*opt-block+*/
15555                                             else 
15556                                               goto MATCH_label_a564;  /*opt-block+*/
15557                                             
15558                                             break;
15559                                           case 2: 
15560                                             MATCH_w_8_24 = 
15561                                               getByte(3 + MATCH_p); 
15562                                             if ((MATCH_w_8_16 & 0x7) 
15563                                                     /* r_m at 16 */ == 4 && 
15564                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15565                                                     /* index at 24 */ && 
15566                                               (MATCH_w_8_24 >> 3 & 0x7) 
15567                                                     /* index at 24 */ < 8)) 
15568                                               goto MATCH_label_a565;  /*opt-block+*/
15569                                             else 
15570                                               goto MATCH_label_a566;  /*opt-block+*/
15571                                             
15572                                             break;
15573                                           case 3: 
15574                                             goto MATCH_label_a563; break;
15575                                           default: assert(0);
15576                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
15577                                               -- mod at 16 --*/ 
15578                                       break;
15579                                     case 3: 
15580                                       
15581                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
15582                                               /* mod at 16 */) {
15583                                           case 0: 
15584                                             
15585                                               switch((MATCH_w_8_16 & 0x7) 
15586                                                     /* r_m at 16 */) {
15587                                                 case 0: case 1: case 2: 
15588                                                 case 3: case 6: case 7: 
15589                                                   goto MATCH_label_a567; 
15590                                                   
15591                                                   break;
15592                                                 case 4: 
15593                                                   MATCH_w_8_24 = 
15594                                                     getByte(3 + MATCH_p); 
15595                                                   if ((MATCH_w_8_24 & 0x7) 
15596                                                           /* base at 24 */ == 5 && 
15597                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15598                                                           /* index at 24 */ && 
15599                                                     (MATCH_w_8_24 >> 3 & 0x7) 
15600                                                           /* index at 24 */ < 8)) 
15601                                                     goto MATCH_label_a569;  /*opt-block+*/
15602                                                   else 
15603                                                     goto MATCH_label_a568;  /*opt-block+*/
15604                                                   
15605                                                   break;
15606                                                 case 5: 
15607                                                   goto MATCH_label_a570; 
15608                                                   
15609                                                   break;
15610                                                 default: assert(0);
15611                                               } /* (MATCH_w_8_16 & 0x7) 
15612                                                     -- r_m at 16 --*/ 
15613                                             break;
15614                                           case 1: 
15615                                             MATCH_w_8_24 = 
15616                                               getByte(3 + MATCH_p); 
15617                                             if ((MATCH_w_8_16 & 0x7) 
15618                                                     /* r_m at 16 */ == 4 && 
15619                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15620                                                     /* index at 24 */ && 
15621                                               (MATCH_w_8_24 >> 3 & 0x7) 
15622                                                     /* index at 24 */ < 8)) { 
15623                                               unsigned Eaddr = 
15624                                                 2 + addressToPC(MATCH_p);
15625                                               nextPC = 5 + MATCH_p; 
15626                                               
15627                                               #line 414 "machine/pentium/disassembler.m"
15628                                               
15629 
15630                                                       sprintf (str,  "RCRB.Ev.1ow", DIS_EADDR16);
15631 
15632                                               
15633 
15634                                               
15635                                               
15636                                               
15637                                             } /*opt-block*//*opt-block+*/
15638                                             else 
15639                                               goto MATCH_label_a568;  /*opt-block+*/
15640                                             
15641                                             break;
15642                                           case 2: 
15643                                             MATCH_w_8_24 = 
15644                                               getByte(3 + MATCH_p); 
15645                                             if ((MATCH_w_8_16 & 0x7) 
15646                                                     /* r_m at 16 */ == 4 && 
15647                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15648                                                     /* index at 24 */ && 
15649                                               (MATCH_w_8_24 >> 3 & 0x7) 
15650                                                     /* index at 24 */ < 8)) 
15651                                               goto MATCH_label_a569;  /*opt-block+*/
15652                                             else 
15653                                               goto MATCH_label_a570;  /*opt-block+*/
15654                                             
15655                                             break;
15656                                           case 3: 
15657                                             goto MATCH_label_a567; break;
15658                                           default: assert(0);
15659                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
15660                                               -- mod at 16 --*/ 
15661                                       break;
15662                                     case 4: 
15663                                       
15664                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
15665                                               /* mod at 16 */) {
15666                                           case 0: 
15667                                             
15668                                               switch((MATCH_w_8_16 & 0x7) 
15669                                                     /* r_m at 16 */) {
15670                                                 case 0: case 1: case 2: 
15671                                                 case 3: case 6: case 7: 
15672                                                   goto MATCH_label_a571; 
15673                                                   
15674                                                   break;
15675                                                 case 4: 
15676                                                   MATCH_w_8_24 = 
15677                                                     getByte(3 + MATCH_p); 
15678                                                   if ((MATCH_w_8_24 & 0x7) 
15679                                                           /* base at 24 */ == 5 && 
15680                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15681                                                           /* index at 24 */ && 
15682                                                     (MATCH_w_8_24 >> 3 & 0x7) 
15683                                                           /* index at 24 */ < 8)) 
15684                                                     goto MATCH_label_a573;  /*opt-block+*/
15685                                                   else 
15686                                                     goto MATCH_label_a572;  /*opt-block+*/
15687                                                   
15688                                                   break;
15689                                                 case 5: 
15690                                                   goto MATCH_label_a574; 
15691                                                   
15692                                                   break;
15693                                                 default: assert(0);
15694                                               } /* (MATCH_w_8_16 & 0x7) 
15695                                                     -- r_m at 16 --*/ 
15696                                             break;
15697                                           case 1: 
15698                                             MATCH_w_8_24 = 
15699                                               getByte(3 + MATCH_p); 
15700                                             if ((MATCH_w_8_16 & 0x7) 
15701                                                     /* r_m at 16 */ == 4 && 
15702                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15703                                                     /* index at 24 */ && 
15704                                               (MATCH_w_8_24 >> 3 & 0x7) 
15705                                                     /* index at 24 */ < 8)) { 
15706                                               unsigned Eaddr = 
15707                                                 2 + addressToPC(MATCH_p);
15708                                               nextPC = 5 + MATCH_p; 
15709                                               
15710                                               #line 402 "machine/pentium/disassembler.m"
15711                                               
15712 
15713                                                       sprintf (str,  "SHLSALB.Ev.1ow", DIS_EADDR16);
15714 
15715                                               
15716 
15717                                               
15718                                               
15719                                               
15720                                             } /*opt-block*//*opt-block+*/
15721                                             else 
15722                                               goto MATCH_label_a572;  /*opt-block+*/
15723                                             
15724                                             break;
15725                                           case 2: 
15726                                             MATCH_w_8_24 = 
15727                                               getByte(3 + MATCH_p); 
15728                                             if ((MATCH_w_8_16 & 0x7) 
15729                                                     /* r_m at 16 */ == 4 && 
15730                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15731                                                     /* index at 24 */ && 
15732                                               (MATCH_w_8_24 >> 3 & 0x7) 
15733                                                     /* index at 24 */ < 8)) 
15734                                               goto MATCH_label_a573;  /*opt-block+*/
15735                                             else 
15736                                               goto MATCH_label_a574;  /*opt-block+*/
15737                                             
15738                                             break;
15739                                           case 3: 
15740                                             goto MATCH_label_a571; break;
15741                                           default: assert(0);
15742                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
15743                                               -- mod at 16 --*/ 
15744                                       break;
15745                                     case 5: 
15746                                       
15747                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
15748                                               /* mod at 16 */) {
15749                                           case 0: 
15750                                             
15751                                               switch((MATCH_w_8_16 & 0x7) 
15752                                                     /* r_m at 16 */) {
15753                                                 case 0: case 1: case 2: 
15754                                                 case 3: case 6: case 7: 
15755                                                   goto MATCH_label_a575; 
15756                                                   
15757                                                   break;
15758                                                 case 4: 
15759                                                   MATCH_w_8_24 = 
15760                                                     getByte(3 + MATCH_p); 
15761                                                   if ((MATCH_w_8_24 & 0x7) 
15762                                                           /* base at 24 */ == 5 && 
15763                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15764                                                           /* index at 24 */ && 
15765                                                     (MATCH_w_8_24 >> 3 & 0x7) 
15766                                                           /* index at 24 */ < 8)) 
15767                                                     goto MATCH_label_a577;  /*opt-block+*/
15768                                                   else 
15769                                                     goto MATCH_label_a576;  /*opt-block+*/
15770                                                   
15771                                                   break;
15772                                                 case 5: 
15773                                                   goto MATCH_label_a578; 
15774                                                   
15775                                                   break;
15776                                                 default: assert(0);
15777                                               } /* (MATCH_w_8_16 & 0x7) 
15778                                                     -- r_m at 16 --*/ 
15779                                             break;
15780                                           case 1: 
15781                                             MATCH_w_8_24 = 
15782                                               getByte(3 + MATCH_p); 
15783                                             if ((MATCH_w_8_16 & 0x7) 
15784                                                     /* r_m at 16 */ == 4 && 
15785                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15786                                                     /* index at 24 */ && 
15787                                               (MATCH_w_8_24 >> 3 & 0x7) 
15788                                                     /* index at 24 */ < 8)) { 
15789                                               unsigned Eaddr = 
15790                                                 2 + addressToPC(MATCH_p);
15791                                               nextPC = 5 + MATCH_p; 
15792                                               
15793                                               #line 390 "machine/pentium/disassembler.m"
15794                                               
15795 
15796                                                       sprintf (str,  "SHRB.Ev.1ow", DIS_EADDR16);
15797 
15798                                               
15799 
15800                                               
15801                                               
15802                                               
15803                                             } /*opt-block*//*opt-block+*/
15804                                             else 
15805                                               goto MATCH_label_a576;  /*opt-block+*/
15806                                             
15807                                             break;
15808                                           case 2: 
15809                                             MATCH_w_8_24 = 
15810                                               getByte(3 + MATCH_p); 
15811                                             if ((MATCH_w_8_16 & 0x7) 
15812                                                     /* r_m at 16 */ == 4 && 
15813                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15814                                                     /* index at 24 */ && 
15815                                               (MATCH_w_8_24 >> 3 & 0x7) 
15816                                                     /* index at 24 */ < 8)) 
15817                                               goto MATCH_label_a577;  /*opt-block+*/
15818                                             else 
15819                                               goto MATCH_label_a578;  /*opt-block+*/
15820                                             
15821                                             break;
15822                                           case 3: 
15823                                             goto MATCH_label_a575; break;
15824                                           default: assert(0);
15825                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
15826                                               -- mod at 16 --*/ 
15827                                       break;
15828                                     case 6: 
15829                                       goto MATCH_label_a39; break;
15830                                     case 7: 
15831                                       
15832                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
15833                                               /* mod at 16 */) {
15834                                           case 0: 
15835                                             
15836                                               switch((MATCH_w_8_16 & 0x7) 
15837                                                     /* r_m at 16 */) {
15838                                                 case 0: case 1: case 2: 
15839                                                 case 3: case 6: case 7: 
15840                                                   goto MATCH_label_a579; 
15841                                                   
15842                                                   break;
15843                                                 case 4: 
15844                                                   MATCH_w_8_24 = 
15845                                                     getByte(3 + MATCH_p); 
15846                                                   if ((MATCH_w_8_24 & 0x7) 
15847                                                           /* base at 24 */ == 5 && 
15848                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15849                                                           /* index at 24 */ && 
15850                                                     (MATCH_w_8_24 >> 3 & 0x7) 
15851                                                           /* index at 24 */ < 8)) 
15852                                                     goto MATCH_label_a581;  /*opt-block+*/
15853                                                   else 
15854                                                     goto MATCH_label_a580;  /*opt-block+*/
15855                                                   
15856                                                   break;
15857                                                 case 5: 
15858                                                   goto MATCH_label_a582; 
15859                                                   
15860                                                   break;
15861                                                 default: assert(0);
15862                                               } /* (MATCH_w_8_16 & 0x7) 
15863                                                     -- r_m at 16 --*/ 
15864                                             break;
15865                                           case 1: 
15866                                             MATCH_w_8_24 = 
15867                                               getByte(3 + MATCH_p); 
15868                                             if ((MATCH_w_8_16 & 0x7) 
15869                                                     /* r_m at 16 */ == 4 && 
15870                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15871                                                     /* index at 24 */ && 
15872                                               (MATCH_w_8_24 >> 3 & 0x7) 
15873                                                     /* index at 24 */ < 8)) { 
15874                                               unsigned Eaddr = 
15875                                                 2 + addressToPC(MATCH_p);
15876                                               nextPC = 5 + MATCH_p; 
15877                                               
15878                                               #line 378 "machine/pentium/disassembler.m"
15879                                               
15880 
15881                                                       sprintf (str,  "SARB.Ev.1ow", DIS_EADDR16);
15882 
15883                                               
15884 
15885                                               
15886                                               
15887                                               
15888                                             } /*opt-block*//*opt-block+*/
15889                                             else 
15890                                               goto MATCH_label_a580;  /*opt-block+*/
15891                                             
15892                                             break;
15893                                           case 2: 
15894                                             MATCH_w_8_24 = 
15895                                               getByte(3 + MATCH_p); 
15896                                             if ((MATCH_w_8_16 & 0x7) 
15897                                                     /* r_m at 16 */ == 4 && 
15898                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15899                                                     /* index at 24 */ && 
15900                                               (MATCH_w_8_24 >> 3 & 0x7) 
15901                                                     /* index at 24 */ < 8)) 
15902                                               goto MATCH_label_a581;  /*opt-block+*/
15903                                             else 
15904                                               goto MATCH_label_a582;  /*opt-block+*/
15905                                             
15906                                             break;
15907                                           case 3: 
15908                                             goto MATCH_label_a579; break;
15909                                           default: assert(0);
15910                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
15911                                               -- mod at 16 --*/ 
15912                                       break;
15913                                     default: assert(0);
15914                                   } /* (MATCH_w_8_16 >> 3 & 0x7) 
15915                                         -- reg_opcode at 16 --*/ 
15916                                 
15917                               } /*opt-block*/
15918                               break;
15919                             case 3: 
15920                               if ((MATCH_w_8_8 >> 3 & 0x1) 
15921                                       /* page at 8 */ == 1) 
15922                                 goto MATCH_label_a39;  /*opt-block+*/
15923                               else { 
15924                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
15925                                 
15926                                   switch((MATCH_w_8_16 >> 3 & 0x7) 
15927                                         /* reg_opcode at 16 */) {
15928                                     case 0: 
15929                                       
15930                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
15931                                               /* mod at 16 */) {
15932                                           case 0: 
15933                                             
15934                                               switch((MATCH_w_8_16 & 0x7) 
15935                                                     /* r_m at 16 */) {
15936                                                 case 0: case 1: case 2: 
15937                                                 case 3: case 6: case 7: 
15938                                                   goto MATCH_label_a583; 
15939                                                   
15940                                                   break;
15941                                                 case 4: 
15942                                                   MATCH_w_8_24 = 
15943                                                     getByte(3 + MATCH_p); 
15944                                                   if ((MATCH_w_8_24 & 0x7) 
15945                                                           /* base at 24 */ == 5 && 
15946                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15947                                                           /* index at 24 */ && 
15948                                                     (MATCH_w_8_24 >> 3 & 0x7) 
15949                                                           /* index at 24 */ < 8)) 
15950                                                     goto MATCH_label_a585;  /*opt-block+*/
15951                                                   else 
15952                                                     goto MATCH_label_a584;  /*opt-block+*/
15953                                                   
15954                                                   break;
15955                                                 case 5: 
15956                                                   goto MATCH_label_a586; 
15957                                                   
15958                                                   break;
15959                                                 default: assert(0);
15960                                               } /* (MATCH_w_8_16 & 0x7) 
15961                                                     -- r_m at 16 --*/ 
15962                                             break;
15963                                           case 1: 
15964                                             MATCH_w_8_24 = 
15965                                               getByte(3 + MATCH_p); 
15966                                             if ((MATCH_w_8_16 & 0x7) 
15967                                                     /* r_m at 16 */ == 4 && 
15968                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15969                                                     /* index at 24 */ && 
15970                                               (MATCH_w_8_24 >> 3 & 0x7) 
15971                                                     /* index at 24 */ < 8)) { 
15972                                               unsigned Eaddr = 
15973                                                 2 + addressToPC(MATCH_p);
15974                                               nextPC = 5 + MATCH_p; 
15975                                               
15976                                               #line 444 "machine/pentium/disassembler.m"
15977                                               
15978 
15979                                                       sprintf (str,  "ROLB.Ev.CLow", DIS_EADDR16);
15980 
15981                                               
15982 
15983                                               
15984                                               
15985                                               
15986                                             } /*opt-block*//*opt-block+*/
15987                                             else 
15988                                               goto MATCH_label_a584;  /*opt-block+*/
15989                                             
15990                                             break;
15991                                           case 2: 
15992                                             MATCH_w_8_24 = 
15993                                               getByte(3 + MATCH_p); 
15994                                             if ((MATCH_w_8_16 & 0x7) 
15995                                                     /* r_m at 16 */ == 4 && 
15996                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
15997                                                     /* index at 24 */ && 
15998                                               (MATCH_w_8_24 >> 3 & 0x7) 
15999                                                     /* index at 24 */ < 8)) 
16000                                               goto MATCH_label_a585;  /*opt-block+*/
16001                                             else 
16002                                               goto MATCH_label_a586;  /*opt-block+*/
16003                                             
16004                                             break;
16005                                           case 3: 
16006                                             goto MATCH_label_a583; break;
16007                                           default: assert(0);
16008                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
16009                                               -- mod at 16 --*/ 
16010                                       break;
16011                                     case 1: 
16012                                       
16013                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
16014                                               /* mod at 16 */) {
16015                                           case 0: 
16016                                             
16017                                               switch((MATCH_w_8_16 & 0x7) 
16018                                                     /* r_m at 16 */) {
16019                                                 case 0: case 1: case 2: 
16020                                                 case 3: case 6: case 7: 
16021                                                   goto MATCH_label_a587; 
16022                                                   
16023                                                   break;
16024                                                 case 4: 
16025                                                   MATCH_w_8_24 = 
16026                                                     getByte(3 + MATCH_p); 
16027                                                   if ((MATCH_w_8_24 & 0x7) 
16028                                                           /* base at 24 */ == 5 && 
16029                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16030                                                           /* index at 24 */ && 
16031                                                     (MATCH_w_8_24 >> 3 & 0x7) 
16032                                                           /* index at 24 */ < 8)) 
16033                                                     goto MATCH_label_a589;  /*opt-block+*/
16034                                                   else 
16035                                                     goto MATCH_label_a588;  /*opt-block+*/
16036                                                   
16037                                                   break;
16038                                                 case 5: 
16039                                                   goto MATCH_label_a590; 
16040                                                   
16041                                                   break;
16042                                                 default: assert(0);
16043                                               } /* (MATCH_w_8_16 & 0x7) 
16044                                                     -- r_m at 16 --*/ 
16045                                             break;
16046                                           case 1: 
16047                                             MATCH_w_8_24 = 
16048                                               getByte(3 + MATCH_p); 
16049                                             if ((MATCH_w_8_16 & 0x7) 
16050                                                     /* r_m at 16 */ == 4 && 
16051                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16052                                                     /* index at 24 */ && 
16053                                               (MATCH_w_8_24 >> 3 & 0x7) 
16054                                                     /* index at 24 */ < 8)) { 
16055                                               unsigned Eaddr = 
16056                                                 2 + addressToPC(MATCH_p);
16057                                               nextPC = 5 + MATCH_p; 
16058                                               
16059                                               #line 432 "machine/pentium/disassembler.m"
16060                                               
16061 
16062                                                       sprintf (str,  "RORB.Ev.CLow", DIS_EADDR16);
16063 
16064                                               
16065 
16066                                               
16067                                               
16068                                               
16069                                             } /*opt-block*//*opt-block+*/
16070                                             else 
16071                                               goto MATCH_label_a588;  /*opt-block+*/
16072                                             
16073                                             break;
16074                                           case 2: 
16075                                             MATCH_w_8_24 = 
16076                                               getByte(3 + MATCH_p); 
16077                                             if ((MATCH_w_8_16 & 0x7) 
16078                                                     /* r_m at 16 */ == 4 && 
16079                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16080                                                     /* index at 24 */ && 
16081                                               (MATCH_w_8_24 >> 3 & 0x7) 
16082                                                     /* index at 24 */ < 8)) 
16083                                               goto MATCH_label_a589;  /*opt-block+*/
16084                                             else 
16085                                               goto MATCH_label_a590;  /*opt-block+*/
16086                                             
16087                                             break;
16088                                           case 3: 
16089                                             goto MATCH_label_a587; break;
16090                                           default: assert(0);
16091                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
16092                                               -- mod at 16 --*/ 
16093                                       break;
16094                                     case 2: 
16095                                       
16096                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
16097                                               /* mod at 16 */) {
16098                                           case 0: 
16099                                             
16100                                               switch((MATCH_w_8_16 & 0x7) 
16101                                                     /* r_m at 16 */) {
16102                                                 case 0: case 1: case 2: 
16103                                                 case 3: case 6: case 7: 
16104                                                   goto MATCH_label_a591; 
16105                                                   
16106                                                   break;
16107                                                 case 4: 
16108                                                   MATCH_w_8_24 = 
16109                                                     getByte(3 + MATCH_p); 
16110                                                   if ((MATCH_w_8_24 & 0x7) 
16111                                                           /* base at 24 */ == 5 && 
16112                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16113                                                           /* index at 24 */ && 
16114                                                     (MATCH_w_8_24 >> 3 & 0x7) 
16115                                                           /* index at 24 */ < 8)) 
16116                                                     goto MATCH_label_a593;  /*opt-block+*/
16117                                                   else 
16118                                                     goto MATCH_label_a592;  /*opt-block+*/
16119                                                   
16120                                                   break;
16121                                                 case 5: 
16122                                                   goto MATCH_label_a594; 
16123                                                   
16124                                                   break;
16125                                                 default: assert(0);
16126                                               } /* (MATCH_w_8_16 & 0x7) 
16127                                                     -- r_m at 16 --*/ 
16128                                             break;
16129                                           case 1: 
16130                                             MATCH_w_8_24 = 
16131                                               getByte(3 + MATCH_p); 
16132                                             if ((MATCH_w_8_16 & 0x7) 
16133                                                     /* r_m at 16 */ == 4 && 
16134                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16135                                                     /* index at 24 */ && 
16136                                               (MATCH_w_8_24 >> 3 & 0x7) 
16137                                                     /* index at 24 */ < 8)) { 
16138                                               unsigned Eaddr = 
16139                                                 2 + addressToPC(MATCH_p);
16140                                               nextPC = 5 + MATCH_p; 
16141                                               
16142                                               #line 420 "machine/pentium/disassembler.m"
16143                                               
16144 
16145                                                       sprintf (str,  "RCLB.Ev.CLow", DIS_EADDR16);
16146 
16147                                               
16148 
16149                                               
16150                                               
16151                                               
16152                                             } /*opt-block*//*opt-block+*/
16153                                             else 
16154                                               goto MATCH_label_a592;  /*opt-block+*/
16155                                             
16156                                             break;
16157                                           case 2: 
16158                                             MATCH_w_8_24 = 
16159                                               getByte(3 + MATCH_p); 
16160                                             if ((MATCH_w_8_16 & 0x7) 
16161                                                     /* r_m at 16 */ == 4 && 
16162                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16163                                                     /* index at 24 */ && 
16164                                               (MATCH_w_8_24 >> 3 & 0x7) 
16165                                                     /* index at 24 */ < 8)) 
16166                                               goto MATCH_label_a593;  /*opt-block+*/
16167                                             else 
16168                                               goto MATCH_label_a594;  /*opt-block+*/
16169                                             
16170                                             break;
16171                                           case 3: 
16172                                             goto MATCH_label_a591; break;
16173                                           default: assert(0);
16174                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
16175                                               -- mod at 16 --*/ 
16176                                       break;
16177                                     case 3: 
16178                                       
16179                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
16180                                               /* mod at 16 */) {
16181                                           case 0: 
16182                                             
16183                                               switch((MATCH_w_8_16 & 0x7) 
16184                                                     /* r_m at 16 */) {
16185                                                 case 0: case 1: case 2: 
16186                                                 case 3: case 6: case 7: 
16187                                                   goto MATCH_label_a595; 
16188                                                   
16189                                                   break;
16190                                                 case 4: 
16191                                                   MATCH_w_8_24 = 
16192                                                     getByte(3 + MATCH_p); 
16193                                                   if ((MATCH_w_8_24 & 0x7) 
16194                                                           /* base at 24 */ == 5 && 
16195                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16196                                                           /* index at 24 */ && 
16197                                                     (MATCH_w_8_24 >> 3 & 0x7) 
16198                                                           /* index at 24 */ < 8)) 
16199                                                     goto MATCH_label_a597;  /*opt-block+*/
16200                                                   else 
16201                                                     goto MATCH_label_a596;  /*opt-block+*/
16202                                                   
16203                                                   break;
16204                                                 case 5: 
16205                                                   goto MATCH_label_a598; 
16206                                                   
16207                                                   break;
16208                                                 default: assert(0);
16209                                               } /* (MATCH_w_8_16 & 0x7) 
16210                                                     -- r_m at 16 --*/ 
16211                                             break;
16212                                           case 1: 
16213                                             MATCH_w_8_24 = 
16214                                               getByte(3 + MATCH_p); 
16215                                             if ((MATCH_w_8_16 & 0x7) 
16216                                                     /* r_m at 16 */ == 4 && 
16217                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16218                                                     /* index at 24 */ && 
16219                                               (MATCH_w_8_24 >> 3 & 0x7) 
16220                                                     /* index at 24 */ < 8)) { 
16221                                               unsigned Eaddr = 
16222                                                 2 + addressToPC(MATCH_p);
16223                                               nextPC = 5 + MATCH_p; 
16224                                               
16225                                               #line 408 "machine/pentium/disassembler.m"
16226                                               
16227 
16228                                                       sprintf (str,  "RCRB.Ev.CLow", DIS_EADDR16);
16229 
16230                                               
16231 
16232                                               
16233                                               
16234                                               
16235                                             } /*opt-block*//*opt-block+*/
16236                                             else 
16237                                               goto MATCH_label_a596;  /*opt-block+*/
16238                                             
16239                                             break;
16240                                           case 2: 
16241                                             MATCH_w_8_24 = 
16242                                               getByte(3 + MATCH_p); 
16243                                             if ((MATCH_w_8_16 & 0x7) 
16244                                                     /* r_m at 16 */ == 4 && 
16245                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16246                                                     /* index at 24 */ && 
16247                                               (MATCH_w_8_24 >> 3 & 0x7) 
16248                                                     /* index at 24 */ < 8)) 
16249                                               goto MATCH_label_a597;  /*opt-block+*/
16250                                             else 
16251                                               goto MATCH_label_a598;  /*opt-block+*/
16252                                             
16253                                             break;
16254                                           case 3: 
16255                                             goto MATCH_label_a595; break;
16256                                           default: assert(0);
16257                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
16258                                               -- mod at 16 --*/ 
16259                                       break;
16260                                     case 4: 
16261                                       
16262                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
16263                                               /* mod at 16 */) {
16264                                           case 0: 
16265                                             
16266                                               switch((MATCH_w_8_16 & 0x7) 
16267                                                     /* r_m at 16 */) {
16268                                                 case 0: case 1: case 2: 
16269                                                 case 3: case 6: case 7: 
16270                                                   goto MATCH_label_a599; 
16271                                                   
16272                                                   break;
16273                                                 case 4: 
16274                                                   MATCH_w_8_24 = 
16275                                                     getByte(3 + MATCH_p); 
16276                                                   if ((MATCH_w_8_24 & 0x7) 
16277                                                           /* base at 24 */ == 5 && 
16278                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16279                                                           /* index at 24 */ && 
16280                                                     (MATCH_w_8_24 >> 3 & 0x7) 
16281                                                           /* index at 24 */ < 8)) 
16282                                                     goto MATCH_label_a601;  /*opt-block+*/
16283                                                   else 
16284                                                     goto MATCH_label_a600;  /*opt-block+*/
16285                                                   
16286                                                   break;
16287                                                 case 5: 
16288                                                   goto MATCH_label_a602; 
16289                                                   
16290                                                   break;
16291                                                 default: assert(0);
16292                                               } /* (MATCH_w_8_16 & 0x7) 
16293                                                     -- r_m at 16 --*/ 
16294                                             break;
16295                                           case 1: 
16296                                             MATCH_w_8_24 = 
16297                                               getByte(3 + MATCH_p); 
16298                                             if ((MATCH_w_8_16 & 0x7) 
16299                                                     /* r_m at 16 */ == 4 && 
16300                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16301                                                     /* index at 24 */ && 
16302                                               (MATCH_w_8_24 >> 3 & 0x7) 
16303                                                     /* index at 24 */ < 8)) { 
16304                                               unsigned Eaddr = 
16305                                                 2 + addressToPC(MATCH_p);
16306                                               nextPC = 5 + MATCH_p; 
16307                                               
16308                                               #line 396 "machine/pentium/disassembler.m"
16309                                               
16310 
16311                                                       sprintf (str,  "SHLSALB.Ev.CLow", DIS_EADDR16);
16312 
16313                                               
16314 
16315                                               
16316                                               
16317                                               
16318                                             } /*opt-block*//*opt-block+*/
16319                                             else 
16320                                               goto MATCH_label_a600;  /*opt-block+*/
16321                                             
16322                                             break;
16323                                           case 2: 
16324                                             MATCH_w_8_24 = 
16325                                               getByte(3 + MATCH_p); 
16326                                             if ((MATCH_w_8_16 & 0x7) 
16327                                                     /* r_m at 16 */ == 4 && 
16328                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16329                                                     /* index at 24 */ && 
16330                                               (MATCH_w_8_24 >> 3 & 0x7) 
16331                                                     /* index at 24 */ < 8)) 
16332                                               goto MATCH_label_a601;  /*opt-block+*/
16333                                             else 
16334                                               goto MATCH_label_a602;  /*opt-block+*/
16335                                             
16336                                             break;
16337                                           case 3: 
16338                                             goto MATCH_label_a599; break;
16339                                           default: assert(0);
16340                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
16341                                               -- mod at 16 --*/ 
16342                                       break;
16343                                     case 5: 
16344                                       
16345                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
16346                                               /* mod at 16 */) {
16347                                           case 0: 
16348                                             
16349                                               switch((MATCH_w_8_16 & 0x7) 
16350                                                     /* r_m at 16 */) {
16351                                                 case 0: case 1: case 2: 
16352                                                 case 3: case 6: case 7: 
16353                                                   goto MATCH_label_a603; 
16354                                                   
16355                                                   break;
16356                                                 case 4: 
16357                                                   MATCH_w_8_24 = 
16358                                                     getByte(3 + MATCH_p); 
16359                                                   if ((MATCH_w_8_24 & 0x7) 
16360                                                           /* base at 24 */ == 5 && 
16361                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16362                                                           /* index at 24 */ && 
16363                                                     (MATCH_w_8_24 >> 3 & 0x7) 
16364                                                           /* index at 24 */ < 8)) 
16365                                                     goto MATCH_label_a605;  /*opt-block+*/
16366                                                   else 
16367                                                     goto MATCH_label_a604;  /*opt-block+*/
16368                                                   
16369                                                   break;
16370                                                 case 5: 
16371                                                   goto MATCH_label_a606; 
16372                                                   
16373                                                   break;
16374                                                 default: assert(0);
16375                                               } /* (MATCH_w_8_16 & 0x7) 
16376                                                     -- r_m at 16 --*/ 
16377                                             break;
16378                                           case 1: 
16379                                             MATCH_w_8_24 = 
16380                                               getByte(3 + MATCH_p); 
16381                                             if ((MATCH_w_8_16 & 0x7) 
16382                                                     /* r_m at 16 */ == 4 && 
16383                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16384                                                     /* index at 24 */ && 
16385                                               (MATCH_w_8_24 >> 3 & 0x7) 
16386                                                     /* index at 24 */ < 8)) { 
16387                                               unsigned Eaddr = 
16388                                                 2 + addressToPC(MATCH_p);
16389                                               nextPC = 5 + MATCH_p; 
16390                                               
16391                                               #line 384 "machine/pentium/disassembler.m"
16392                                               
16393 
16394                                                       sprintf (str,  "SHRB.Ev.CLow", DIS_EADDR16);
16395 
16396                                               
16397 
16398                                               
16399                                               
16400                                               
16401                                             } /*opt-block*//*opt-block+*/
16402                                             else 
16403                                               goto MATCH_label_a604;  /*opt-block+*/
16404                                             
16405                                             break;
16406                                           case 2: 
16407                                             MATCH_w_8_24 = 
16408                                               getByte(3 + MATCH_p); 
16409                                             if ((MATCH_w_8_16 & 0x7) 
16410                                                     /* r_m at 16 */ == 4 && 
16411                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16412                                                     /* index at 24 */ && 
16413                                               (MATCH_w_8_24 >> 3 & 0x7) 
16414                                                     /* index at 24 */ < 8)) 
16415                                               goto MATCH_label_a605;  /*opt-block+*/
16416                                             else 
16417                                               goto MATCH_label_a606;  /*opt-block+*/
16418                                             
16419                                             break;
16420                                           case 3: 
16421                                             goto MATCH_label_a603; break;
16422                                           default: assert(0);
16423                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
16424                                               -- mod at 16 --*/ 
16425                                       break;
16426                                     case 6: 
16427                                       goto MATCH_label_a39; break;
16428                                     case 7: 
16429                                       
16430                                         switch((MATCH_w_8_16 >> 6 & 0x3) 
16431                                               /* mod at 16 */) {
16432                                           case 0: 
16433                                             
16434                                               switch((MATCH_w_8_16 & 0x7) 
16435                                                     /* r_m at 16 */) {
16436                                                 case 0: case 1: case 2: 
16437                                                 case 3: case 6: case 7: 
16438                                                   goto MATCH_label_a607; 
16439                                                   
16440                                                   break;
16441                                                 case 4: 
16442                                                   MATCH_w_8_24 = 
16443                                                     getByte(3 + MATCH_p); 
16444                                                   if ((MATCH_w_8_24 & 0x7) 
16445                                                           /* base at 24 */ == 5 && 
16446                                                     (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16447                                                           /* index at 24 */ && 
16448                                                     (MATCH_w_8_24 >> 3 & 0x7) 
16449                                                           /* index at 24 */ < 8)) 
16450                                                     goto MATCH_label_a609;  /*opt-block+*/
16451                                                   else 
16452                                                     goto MATCH_label_a608;  /*opt-block+*/
16453                                                   
16454                                                   break;
16455                                                 case 5: 
16456                                                   goto MATCH_label_a610; 
16457                                                   
16458                                                   break;
16459                                                 default: assert(0);
16460                                               } /* (MATCH_w_8_16 & 0x7) 
16461                                                     -- r_m at 16 --*/ 
16462                                             break;
16463                                           case 1: 
16464                                             MATCH_w_8_24 = 
16465                                               getByte(3 + MATCH_p); 
16466                                             if ((MATCH_w_8_16 & 0x7) 
16467                                                     /* r_m at 16 */ == 4 && 
16468                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16469                                                     /* index at 24 */ && 
16470                                               (MATCH_w_8_24 >> 3 & 0x7) 
16471                                                     /* index at 24 */ < 8)) { 
16472                                               unsigned Eaddr = 
16473                                                 2 + addressToPC(MATCH_p);
16474                                               nextPC = 5 + MATCH_p; 
16475                                               
16476                                               #line 372 "machine/pentium/disassembler.m"
16477                                               
16478 
16479                                                       sprintf (str,  "SARB.Ev.CLow", DIS_EADDR16);
16480 
16481                                               
16482 
16483                                               
16484                                               
16485                                               
16486                                             } /*opt-block*//*opt-block+*/
16487                                             else 
16488                                               goto MATCH_label_a608;  /*opt-block+*/
16489                                             
16490                                             break;
16491                                           case 2: 
16492                                             MATCH_w_8_24 = 
16493                                               getByte(3 + MATCH_p); 
16494                                             if ((MATCH_w_8_16 & 0x7) 
16495                                                     /* r_m at 16 */ == 4 && 
16496                                               (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16497                                                     /* index at 24 */ && 
16498                                               (MATCH_w_8_24 >> 3 & 0x7) 
16499                                                     /* index at 24 */ < 8)) 
16500                                               goto MATCH_label_a609;  /*opt-block+*/
16501                                             else 
16502                                               goto MATCH_label_a610;  /*opt-block+*/
16503                                             
16504                                             break;
16505                                           case 3: 
16506                                             goto MATCH_label_a607; break;
16507                                           default: assert(0);
16508                                         } /* (MATCH_w_8_16 >> 6 & 0x3) 
16509                                               -- mod at 16 --*/ 
16510                                       break;
16511                                     default: assert(0);
16512                                   } /* (MATCH_w_8_16 >> 3 & 0x7) 
16513                                         -- reg_opcode at 16 --*/ 
16514                                 
16515                               } /*opt-block*/
16516                               break;
16517                             default: assert(0);
16518                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
16519                         break;
16520                       case 15: 
16521                         if ((MATCH_w_8_8 & 0x7) /* col at 8 */ == 7) 
16522                           if ((MATCH_w_8_8 >> 3 & 0x1) 
16523                                   /* page at 8 */ == 1) { 
16524                             MATCH_w_8_16 = getByte(2 + MATCH_p); 
16525                             
16526                               switch((MATCH_w_8_16 >> 3 & 0x7) 
16527                                     /* reg_opcode at 16 */) {
16528                                 case 0: 
16529                                   
16530                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
16531                                           /* mod at 16 */) {
16532                                       case 0: 
16533                                         
16534                                           switch((MATCH_w_8_16 & 0x7) 
16535                                                 /* r_m at 16 */) {
16536                                             case 0: case 1: case 2: case 3: 
16537                                             case 6: case 7: 
16538                                               goto MATCH_label_a639; break;
16539                                             case 4: 
16540                                               MATCH_w_8_24 = 
16541                                                 getByte(3 + MATCH_p); 
16542                                               if ((MATCH_w_8_24 & 0x7) 
16543                                                       /* base at 24 */ == 5 && 
16544                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16545                                                       /* index at 24 */ && 
16546                                                 (MATCH_w_8_24 >> 3 & 0x7) 
16547                                                       /* index at 24 */ < 8)) 
16548                                                 goto MATCH_label_a641;  /*opt-block+*/
16549                                               else 
16550                                                 goto MATCH_label_a640;  /*opt-block+*/
16551                                               
16552                                               break;
16553                                             case 5: 
16554                                               goto MATCH_label_a642; break;
16555                                             default: assert(0);
16556                                           } /* (MATCH_w_8_16 & 0x7) 
16557                                                 -- r_m at 16 --*/ 
16558                                         break;
16559                                       case 1: 
16560                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
16561                                         if ((MATCH_w_8_16 & 0x7) 
16562                                                 /* r_m at 16 */ == 4 && 
16563                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16564                                                 /* index at 24 */ && 
16565                                           (MATCH_w_8_24 >> 3 & 0x7) 
16566                                                 /* index at 24 */ < 8)) { 
16567                                           unsigned Eaddr = 
16568                                             2 + addressToPC(MATCH_p);
16569                                           nextPC = 5 + MATCH_p; 
16570                                           
16571                                           #line 833 "machine/pentium/disassembler.m"
16572                                           
16573 
16574                                                   sprintf (str,  "INC.Evow", DIS_EADDR16);
16575 
16576                                           
16577 
16578                                           
16579                                           
16580                                           
16581                                         } /*opt-block*//*opt-block+*/
16582                                         else 
16583                                           goto MATCH_label_a640;  /*opt-block+*/
16584                                         
16585                                         break;
16586                                       case 2: 
16587                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
16588                                         if ((MATCH_w_8_16 & 0x7) 
16589                                                 /* r_m at 16 */ == 4 && 
16590                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16591                                                 /* index at 24 */ && 
16592                                           (MATCH_w_8_24 >> 3 & 0x7) 
16593                                                 /* index at 24 */ < 8)) 
16594                                           goto MATCH_label_a641;  /*opt-block+*/
16595                                         else 
16596                                           goto MATCH_label_a642;  /*opt-block+*/
16597                                         
16598                                         break;
16599                                       case 3: 
16600                                         goto MATCH_label_a639; break;
16601                                       default: assert(0);
16602                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
16603                                           -- mod at 16 --*/ 
16604                                   break;
16605                                 case 1: 
16606                                   
16607                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
16608                                           /* mod at 16 */) {
16609                                       case 0: 
16610                                         
16611                                           switch((MATCH_w_8_16 & 0x7) 
16612                                                 /* r_m at 16 */) {
16613                                             case 0: case 1: case 2: case 3: 
16614                                             case 6: case 7: 
16615                                               goto MATCH_label_a643; break;
16616                                             case 4: 
16617                                               MATCH_w_8_24 = 
16618                                                 getByte(3 + MATCH_p); 
16619                                               if ((MATCH_w_8_24 & 0x7) 
16620                                                       /* base at 24 */ == 5 && 
16621                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16622                                                       /* index at 24 */ && 
16623                                                 (MATCH_w_8_24 >> 3 & 0x7) 
16624                                                       /* index at 24 */ < 8)) 
16625                                                 goto MATCH_label_a645;  /*opt-block+*/
16626                                               else 
16627                                                 goto MATCH_label_a644;  /*opt-block+*/
16628                                               
16629                                               break;
16630                                             case 5: 
16631                                               goto MATCH_label_a646; break;
16632                                             default: assert(0);
16633                                           } /* (MATCH_w_8_16 & 0x7) 
16634                                                 -- r_m at 16 --*/ 
16635                                         break;
16636                                       case 1: 
16637                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
16638                                         if ((MATCH_w_8_16 & 0x7) 
16639                                                 /* r_m at 16 */ == 4 && 
16640                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16641                                                 /* index at 24 */ && 
16642                                           (MATCH_w_8_24 >> 3 & 0x7) 
16643                                                 /* index at 24 */ < 8)) { 
16644                                           unsigned Eaddr = 
16645                                             2 + addressToPC(MATCH_p);
16646                                           nextPC = 5 + MATCH_p; 
16647                                           
16648                                           #line 917 "machine/pentium/disassembler.m"
16649                                           
16650 
16651                                                   sprintf (str,  "DEC.Evow", DIS_EADDR16);
16652 
16653                                           
16654 
16655                                           
16656                                           
16657                                           
16658                                         } /*opt-block*//*opt-block+*/
16659                                         else 
16660                                           goto MATCH_label_a644;  /*opt-block+*/
16661                                         
16662                                         break;
16663                                       case 2: 
16664                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
16665                                         if ((MATCH_w_8_16 & 0x7) 
16666                                                 /* r_m at 16 */ == 4 && 
16667                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16668                                                 /* index at 24 */ && 
16669                                           (MATCH_w_8_24 >> 3 & 0x7) 
16670                                                 /* index at 24 */ < 8)) 
16671                                           goto MATCH_label_a645;  /*opt-block+*/
16672                                         else 
16673                                           goto MATCH_label_a646;  /*opt-block+*/
16674                                         
16675                                         break;
16676                                       case 3: 
16677                                         goto MATCH_label_a643; break;
16678                                       default: assert(0);
16679                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
16680                                           -- mod at 16 --*/ 
16681                                   break;
16682                                 case 2: case 3: case 4: case 5: case 7: 
16683                                   goto MATCH_label_a39; break;
16684                                 case 6: 
16685                                   
16686                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
16687                                           /* mod at 16 */) {
16688                                       case 0: 
16689                                         
16690                                           switch((MATCH_w_8_16 & 0x7) 
16691                                                 /* r_m at 16 */) {
16692                                             case 0: case 1: case 2: case 3: 
16693                                             case 6: case 7: 
16694                                               goto MATCH_label_a647; break;
16695                                             case 4: 
16696                                               MATCH_w_8_24 = 
16697                                                 getByte(3 + MATCH_p); 
16698                                               if ((MATCH_w_8_24 & 0x7) 
16699                                                       /* base at 24 */ == 5 && 
16700                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16701                                                       /* index at 24 */ && 
16702                                                 (MATCH_w_8_24 >> 3 & 0x7) 
16703                                                       /* index at 24 */ < 8)) 
16704                                                 goto MATCH_label_a649;  /*opt-block+*/
16705                                               else 
16706                                                 goto MATCH_label_a648;  /*opt-block+*/
16707                                               
16708                                               break;
16709                                             case 5: 
16710                                               goto MATCH_label_a650; break;
16711                                             default: assert(0);
16712                                           } /* (MATCH_w_8_16 & 0x7) 
16713                                                 -- r_m at 16 --*/ 
16714                                         break;
16715                                       case 1: 
16716                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
16717                                         if ((MATCH_w_8_16 & 0x7) 
16718                                                 /* r_m at 16 */ == 4 && 
16719                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16720                                                 /* index at 24 */ && 
16721                                           (MATCH_w_8_24 >> 3 & 0x7) 
16722                                                 /* index at 24 */ < 8)) { 
16723                                           unsigned Eaddr = 
16724                                             2 + addressToPC(MATCH_p);
16725                                           nextPC = 5 + MATCH_p; 
16726                                           
16727                                           #line 546 "machine/pentium/disassembler.m"
16728                                           
16729 
16730                                                   sprintf (str,  "PUSH.Evow", DIS_EADDR16);
16731 
16732                                           
16733 
16734                                           
16735                                           
16736                                           
16737                                         } /*opt-block*//*opt-block+*/
16738                                         else 
16739                                           goto MATCH_label_a648;  /*opt-block+*/
16740                                         
16741                                         break;
16742                                       case 2: 
16743                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
16744                                         if ((MATCH_w_8_16 & 0x7) 
16745                                                 /* r_m at 16 */ == 4 && 
16746                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16747                                                 /* index at 24 */ && 
16748                                           (MATCH_w_8_24 >> 3 & 0x7) 
16749                                                 /* index at 24 */ < 8)) 
16750                                           goto MATCH_label_a649;  /*opt-block+*/
16751                                         else 
16752                                           goto MATCH_label_a650;  /*opt-block+*/
16753                                         
16754                                         break;
16755                                       case 3: 
16756                                         goto MATCH_label_a647; break;
16757                                       default: assert(0);
16758                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
16759                                           -- mod at 16 --*/ 
16760                                   break;
16761                                 default: assert(0);
16762                               } /* (MATCH_w_8_16 >> 3 & 0x7) 
16763                                     -- reg_opcode at 16 --*/ 
16764                             
16765                           } /*opt-block*/
16766                           else { 
16767                             MATCH_w_8_16 = getByte(2 + MATCH_p); 
16768                             
16769                               switch((MATCH_w_8_16 >> 3 & 0x7) 
16770                                     /* reg_opcode at 16 */) {
16771                                 case 0: 
16772                                   
16773                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
16774                                           /* mod at 16 */) {
16775                                       case 0: 
16776                                         
16777                                           switch((MATCH_w_8_16 & 0x7) 
16778                                                 /* r_m at 16 */) {
16779                                             case 0: case 1: case 2: case 3: 
16780                                             case 6: case 7: 
16781                                               MATCH_w_16_24 = 
16782                                                 getWord(3 + MATCH_p); 
16783                                               goto MATCH_label_a611; 
16784                                               
16785                                               break;
16786                                             case 4: 
16787                                               MATCH_w_8_24 = 
16788                                                 getByte(3 + MATCH_p); 
16789                                               if ((MATCH_w_8_24 & 0x7) 
16790                                                       /* base at 24 */ == 5 && 
16791                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16792                                                       /* index at 24 */ && 
16793                                                 (MATCH_w_8_24 >> 3 & 0x7) 
16794                                                       /* index at 24 */ < 8)) { 
16795                                                 MATCH_w_16_64 = 
16796                                                   getWord(8 + MATCH_p); 
16797                                                 goto MATCH_label_a613; 
16798                                                 
16799                                               } /*opt-block*/
16800                                               else { 
16801                                                 MATCH_w_16_32 = 
16802                                                   getWord(4 + MATCH_p); 
16803                                                 goto MATCH_label_a612; 
16804                                                 
16805                                               } /*opt-block*/
16806                                               
16807                                               break;
16808                                             case 5: 
16809                                               MATCH_w_16_56 = 
16810                                                 getWord(7 + MATCH_p); 
16811                                               goto MATCH_label_a614; 
16812                                               
16813                                               break;
16814                                             default: assert(0);
16815                                           } /* (MATCH_w_8_16 & 0x7) 
16816                                                 -- r_m at 16 --*/ 
16817                                         break;
16818                                       case 1: 
16819                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
16820                                         if ((MATCH_w_8_16 & 0x7) 
16821                                                 /* r_m at 16 */ == 4 && 
16822                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16823                                                 /* index at 24 */ && 
16824                                           (MATCH_w_8_24 >> 3 & 0x7) 
16825                                                 /* index at 24 */ < 8)) { 
16826                                           MATCH_w_16_40 = 
16827                                             getWord(5 + MATCH_p); 
16828                                           { 
16829                                             unsigned Eaddr = 
16830                                               2 + addressToPC(MATCH_p);
16831                                             unsigned i16 = 
16832                                               (MATCH_w_16_40 & 0xffff) 
16833                                                     /* i16 at 40 */;
16834                                             nextPC = 7 + MATCH_p; 
16835                                             
16836                                             #line 107 "machine/pentium/disassembler.m"
16837                                             
16838 
16839                                                     sprintf (str,  "TEST.Ew.Iw", DIS_EADDR16, DIS_I16);
16840 
16841                                             
16842 
16843                                             
16844                                             
16845                                             
16846                                           }
16847                                           
16848                                         } /*opt-block*/
16849                                         else { 
16850                                           MATCH_w_16_32 = 
16851                                             getWord(4 + MATCH_p); 
16852                                           goto MATCH_label_a612; 
16853                                           
16854                                         } /*opt-block*/
16855                                         
16856                                         break;
16857                                       case 2: 
16858                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
16859                                         if ((MATCH_w_8_16 & 0x7) 
16860                                                 /* r_m at 16 */ == 4 && 
16861                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16862                                                 /* index at 24 */ && 
16863                                           (MATCH_w_8_24 >> 3 & 0x7) 
16864                                                 /* index at 24 */ < 8)) { 
16865                                           MATCH_w_16_64 = 
16866                                             getWord(8 + MATCH_p); 
16867                                           goto MATCH_label_a613; 
16868                                           
16869                                         } /*opt-block*/
16870                                         else { 
16871                                           MATCH_w_16_56 = 
16872                                             getWord(7 + MATCH_p); 
16873                                           goto MATCH_label_a614; 
16874                                           
16875                                         } /*opt-block*/
16876                                         
16877                                         break;
16878                                       case 3: 
16879                                         MATCH_w_16_24 = getWord(3 + MATCH_p); 
16880                                         goto MATCH_label_a611; 
16881                                         
16882                                         break;
16883                                       default: assert(0);
16884                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
16885                                           -- mod at 16 --*/ 
16886                                   break;
16887                                 case 1: 
16888                                   goto MATCH_label_a39; break;
16889                                 case 2: 
16890                                   
16891                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
16892                                           /* mod at 16 */) {
16893                                       case 0: 
16894                                         
16895                                           switch((MATCH_w_8_16 & 0x7) 
16896                                                 /* r_m at 16 */) {
16897                                             case 0: case 1: case 2: case 3: 
16898                                             case 6: case 7: 
16899                                               goto MATCH_label_a615; break;
16900                                             case 4: 
16901                                               MATCH_w_8_24 = 
16902                                                 getByte(3 + MATCH_p); 
16903                                               if ((MATCH_w_8_24 & 0x7) 
16904                                                       /* base at 24 */ == 5 && 
16905                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16906                                                       /* index at 24 */ && 
16907                                                 (MATCH_w_8_24 >> 3 & 0x7) 
16908                                                       /* index at 24 */ < 8)) 
16909                                                 goto MATCH_label_a617;  /*opt-block+*/
16910                                               else 
16911                                                 goto MATCH_label_a616;  /*opt-block+*/
16912                                               
16913                                               break;
16914                                             case 5: 
16915                                               goto MATCH_label_a618; break;
16916                                             default: assert(0);
16917                                           } /* (MATCH_w_8_16 & 0x7) 
16918                                                 -- r_m at 16 --*/ 
16919                                         break;
16920                                       case 1: 
16921                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
16922                                         if ((MATCH_w_8_16 & 0x7) 
16923                                                 /* r_m at 16 */ == 4 && 
16924                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16925                                                 /* index at 24 */ && 
16926                                           (MATCH_w_8_24 >> 3 & 0x7) 
16927                                                 /* index at 24 */ < 8)) { 
16928                                           unsigned Eaddr = 
16929                                             2 + addressToPC(MATCH_p);
16930                                           nextPC = 5 + MATCH_p; 
16931                                           
16932                                           #line 618 "machine/pentium/disassembler.m"
16933                                           
16934 
16935                                                   sprintf (str,  "NOTow", DIS_EADDR16);
16936 
16937                                           
16938 
16939                                           
16940                                           
16941                                           
16942                                         } /*opt-block*//*opt-block+*/
16943                                         else 
16944                                           goto MATCH_label_a616;  /*opt-block+*/
16945                                         
16946                                         break;
16947                                       case 2: 
16948                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
16949                                         if ((MATCH_w_8_16 & 0x7) 
16950                                                 /* r_m at 16 */ == 4 && 
16951                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16952                                                 /* index at 24 */ && 
16953                                           (MATCH_w_8_24 >> 3 & 0x7) 
16954                                                 /* index at 24 */ < 8)) 
16955                                           goto MATCH_label_a617;  /*opt-block+*/
16956                                         else 
16957                                           goto MATCH_label_a618;  /*opt-block+*/
16958                                         
16959                                         break;
16960                                       case 3: 
16961                                         goto MATCH_label_a615; break;
16962                                       default: assert(0);
16963                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
16964                                           -- mod at 16 --*/ 
16965                                   break;
16966                                 case 3: 
16967                                   
16968                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
16969                                           /* mod at 16 */) {
16970                                       case 0: 
16971                                         
16972                                           switch((MATCH_w_8_16 & 0x7) 
16973                                                 /* r_m at 16 */) {
16974                                             case 0: case 1: case 2: case 3: 
16975                                             case 6: case 7: 
16976                                               goto MATCH_label_a619; break;
16977                                             case 4: 
16978                                               MATCH_w_8_24 = 
16979                                                 getByte(3 + MATCH_p); 
16980                                               if ((MATCH_w_8_24 & 0x7) 
16981                                                       /* base at 24 */ == 5 && 
16982                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
16983                                                       /* index at 24 */ && 
16984                                                 (MATCH_w_8_24 >> 3 & 0x7) 
16985                                                       /* index at 24 */ < 8)) 
16986                                                 goto MATCH_label_a621;  /*opt-block+*/
16987                                               else 
16988                                                 goto MATCH_label_a620;  /*opt-block+*/
16989                                               
16990                                               break;
16991                                             case 5: 
16992                                               goto MATCH_label_a622; break;
16993                                             default: assert(0);
16994                                           } /* (MATCH_w_8_16 & 0x7) 
16995                                                 -- r_m at 16 --*/ 
16996                                         break;
16997                                       case 1: 
16998                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
16999                                         if ((MATCH_w_8_16 & 0x7) 
17000                                                 /* r_m at 16 */ == 4 && 
17001                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
17002                                                 /* index at 24 */ && 
17003                                           (MATCH_w_8_24 >> 3 & 0x7) 
17004                                                 /* index at 24 */ < 8)) { 
17005                                           unsigned Eaddr = 
17006                                             2 + addressToPC(MATCH_p);
17007                                           nextPC = 5 + MATCH_p; 
17008                                           
17009                                           #line 627 "machine/pentium/disassembler.m"
17010                                           
17011 
17012                                                   sprintf (str,  "NEGow", DIS_EADDR16);
17013 
17014                                           
17015 
17016                                           
17017                                           
17018                                           
17019                                         } /*opt-block*//*opt-block+*/
17020                                         else 
17021                                           goto MATCH_label_a620;  /*opt-block+*/
17022                                         
17023                                         break;
17024                                       case 2: 
17025                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
17026                                         if ((MATCH_w_8_16 & 0x7) 
17027                                                 /* r_m at 16 */ == 4 && 
17028                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
17029                                                 /* index at 24 */ && 
17030                                           (MATCH_w_8_24 >> 3 & 0x7) 
17031                                                 /* index at 24 */ < 8)) 
17032                                           goto MATCH_label_a621;  /*opt-block+*/
17033                                         else 
17034                                           goto MATCH_label_a622;  /*opt-block+*/
17035                                         
17036                                         break;
17037                                       case 3: 
17038                                         goto MATCH_label_a619; break;
17039                                       default: assert(0);
17040                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
17041                                           -- mod at 16 --*/ 
17042                                   break;
17043                                 case 4: 
17044                                   
17045                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
17046                                           /* mod at 16 */) {
17047                                       case 0: 
17048                                         
17049                                           switch((MATCH_w_8_16 & 0x7) 
17050                                                 /* r_m at 16 */) {
17051                                             case 0: case 1: case 2: case 3: 
17052                                             case 6: case 7: 
17053                                               goto MATCH_label_a623; break;
17054                                             case 4: 
17055                                               MATCH_w_8_24 = 
17056                                                 getByte(3 + MATCH_p); 
17057                                               if ((MATCH_w_8_24 & 0x7) 
17058                                                       /* base at 24 */ == 5 && 
17059                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
17060                                                       /* index at 24 */ && 
17061                                                 (MATCH_w_8_24 >> 3 & 0x7) 
17062                                                       /* index at 24 */ < 8)) 
17063                                                 goto MATCH_label_a625;  /*opt-block+*/
17064                                               else 
17065                                                 goto MATCH_label_a624;  /*opt-block+*/
17066                                               
17067                                               break;
17068                                             case 5: 
17069                                               goto MATCH_label_a626; break;
17070                                             default: assert(0);
17071                                           } /* (MATCH_w_8_16 & 0x7) 
17072                                                 -- r_m at 16 --*/ 
17073                                         break;
17074                                       case 1: 
17075                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
17076                                         if ((MATCH_w_8_16 & 0x7) 
17077                                                 /* r_m at 16 */ == 4 && 
17078                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
17079                                                 /* index at 24 */ && 
17080                                           (MATCH_w_8_24 >> 3 & 0x7) 
17081                                                 /* index at 24 */ < 8)) { 
17082                                           unsigned Eaddr = 
17083                                             2 + addressToPC(MATCH_p);
17084                                           nextPC = 5 + MATCH_p; 
17085                                           
17086                                           #line 636 "machine/pentium/disassembler.m"
17087                                           
17088 
17089                                                   sprintf (str,  "MUL.AXow", DIS_EADDR16);
17090 
17091                                           
17092 
17093                                           
17094                                           
17095                                           
17096                                         } /*opt-block*//*opt-block+*/
17097                                         else 
17098                                           goto MATCH_label_a624;  /*opt-block+*/
17099                                         
17100                                         break;
17101                                       case 2: 
17102                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
17103                                         if ((MATCH_w_8_16 & 0x7) 
17104                                                 /* r_m at 16 */ == 4 && 
17105                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
17106                                                 /* index at 24 */ && 
17107                                           (MATCH_w_8_24 >> 3 & 0x7) 
17108                                                 /* index at 24 */ < 8)) 
17109                                           goto MATCH_label_a625;  /*opt-block+*/
17110                                         else 
17111                                           goto MATCH_label_a626;  /*opt-block+*/
17112                                         
17113                                         break;
17114                                       case 3: 
17115                                         goto MATCH_label_a623; break;
17116                                       default: assert(0);
17117                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
17118                                           -- mod at 16 --*/ 
17119                                   break;
17120                                 case 5: 
17121                                   
17122                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
17123                                           /* mod at 16 */) {
17124                                       case 0: 
17125                                         
17126                                           switch((MATCH_w_8_16 & 0x7) 
17127                                                 /* r_m at 16 */) {
17128                                             case 0: case 1: case 2: case 3: 
17129                                             case 6: case 7: 
17130                                               goto MATCH_label_a627; break;
17131                                             case 4: 
17132                                               MATCH_w_8_24 = 
17133                                                 getByte(3 + MATCH_p); 
17134                                               if ((MATCH_w_8_24 & 0x7) 
17135                                                       /* base at 24 */ == 5 && 
17136                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
17137                                                       /* index at 24 */ && 
17138                                                 (MATCH_w_8_24 >> 3 & 0x7) 
17139                                                       /* index at 24 */ < 8)) 
17140                                                 goto MATCH_label_a629;  /*opt-block+*/
17141                                               else 
17142                                                 goto MATCH_label_a628;  /*opt-block+*/
17143                                               
17144                                               break;
17145                                             case 5: 
17146                                               goto MATCH_label_a630; break;
17147                                             default: assert(0);
17148                                           } /* (MATCH_w_8_16 & 0x7) 
17149                                                 -- r_m at 16 --*/ 
17150                                         break;
17151                                       case 1: 
17152                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
17153                                         if ((MATCH_w_8_16 & 0x7) 
17154                                                 /* r_m at 16 */ == 4 && 
17155                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
17156                                                 /* index at 24 */ && 
17157                                           (MATCH_w_8_24 >> 3 & 0x7) 
17158                                                 /* index at 24 */ < 8)) { 
17159                                           unsigned Eaddr = 
17160                                             2 + addressToPC(MATCH_p);
17161                                           nextPC = 5 + MATCH_p; 
17162                                           
17163                                           #line 878 "machine/pentium/disassembler.m"
17164                                           
17165 
17166                                                   sprintf (str,  "IMULow", DIS_EADDR16);
17167 
17168                                           
17169 
17170                                           
17171                                           
17172                                           
17173                                         } /*opt-block*//*opt-block+*/
17174                                         else 
17175                                           goto MATCH_label_a628;  /*opt-block+*/
17176                                         
17177                                         break;
17178                                       case 2: 
17179                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
17180                                         if ((MATCH_w_8_16 & 0x7) 
17181                                                 /* r_m at 16 */ == 4 && 
17182                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
17183                                                 /* index at 24 */ && 
17184                                           (MATCH_w_8_24 >> 3 & 0x7) 
17185                                                 /* index at 24 */ < 8)) 
17186                                           goto MATCH_label_a629;  /*opt-block+*/
17187                                         else 
17188                                           goto MATCH_label_a630;  /*opt-block+*/
17189                                         
17190                                         break;
17191                                       case 3: 
17192                                         goto MATCH_label_a627; break;
17193                                       default: assert(0);
17194                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
17195                                           -- mod at 16 --*/ 
17196                                   break;
17197                                 case 6: 
17198                                   
17199                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
17200                                           /* mod at 16 */) {
17201                                       case 0: 
17202                                         
17203                                           switch((MATCH_w_8_16 & 0x7) 
17204                                                 /* r_m at 16 */) {
17205                                             case 0: case 1: case 2: case 3: 
17206                                             case 6: case 7: 
17207                                               goto MATCH_label_a631; break;
17208                                             case 4: 
17209                                               MATCH_w_8_24 = 
17210                                                 getByte(3 + MATCH_p); 
17211                                               if ((MATCH_w_8_24 & 0x7) 
17212                                                       /* base at 24 */ == 5 && 
17213                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
17214                                                       /* index at 24 */ && 
17215                                                 (MATCH_w_8_24 >> 3 & 0x7) 
17216                                                       /* index at 24 */ < 8)) 
17217                                                 goto MATCH_label_a633;  /*opt-block+*/
17218                                               else 
17219                                                 goto MATCH_label_a632;  /*opt-block+*/
17220                                               
17221                                               break;
17222                                             case 5: 
17223                                               goto MATCH_label_a634; break;
17224                                             default: assert(0);
17225                                           } /* (MATCH_w_8_16 & 0x7) 
17226                                                 -- r_m at 16 --*/ 
17227                                         break;
17228                                       case 1: 
17229                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
17230                                         if ((MATCH_w_8_16 & 0x7) 
17231                                                 /* r_m at 16 */ == 4 && 
17232                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
17233                                                 /* index at 24 */ && 
17234                                           (MATCH_w_8_24 >> 3 & 0x7) 
17235                                                 /* index at 24 */ < 8)) { 
17236                                           unsigned Eaddr = 
17237                                             2 + addressToPC(MATCH_p);
17238                                           nextPC = 5 + MATCH_p; 
17239                                           
17240                                           #line 902 "machine/pentium/disassembler.m"
17241                                           
17242 
17243                                                   sprintf (str,  "DIVAX", DIS_EADDR16);
17244 
17245                                           
17246 
17247                                           
17248                                           
17249                                           
17250                                         } /*opt-block*//*opt-block+*/
17251                                         else 
17252                                           goto MATCH_label_a632;  /*opt-block+*/
17253                                         
17254                                         break;
17255                                       case 2: 
17256                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
17257                                         if ((MATCH_w_8_16 & 0x7) 
17258                                                 /* r_m at 16 */ == 4 && 
17259                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
17260                                                 /* index at 24 */ && 
17261                                           (MATCH_w_8_24 >> 3 & 0x7) 
17262                                                 /* index at 24 */ < 8)) 
17263                                           goto MATCH_label_a633;  /*opt-block+*/
17264                                         else 
17265                                           goto MATCH_label_a634;  /*opt-block+*/
17266                                         
17267                                         break;
17268                                       case 3: 
17269                                         goto MATCH_label_a631; break;
17270                                       default: assert(0);
17271                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
17272                                           -- mod at 16 --*/ 
17273                                   break;
17274                                 case 7: 
17275                                   
17276                                     switch((MATCH_w_8_16 >> 6 & 0x3) 
17277                                           /* mod at 16 */) {
17278                                       case 0: 
17279                                         
17280                                           switch((MATCH_w_8_16 & 0x7) 
17281                                                 /* r_m at 16 */) {
17282                                             case 0: case 1: case 2: case 3: 
17283                                             case 6: case 7: 
17284                                               goto MATCH_label_a635; break;
17285                                             case 4: 
17286                                               MATCH_w_8_24 = 
17287                                                 getByte(3 + MATCH_p); 
17288                                               if ((MATCH_w_8_24 & 0x7) 
17289                                                       /* base at 24 */ == 5 && 
17290                                                 (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
17291                                                       /* index at 24 */ && 
17292                                                 (MATCH_w_8_24 >> 3 & 0x7) 
17293                                                       /* index at 24 */ < 8)) 
17294                                                 goto MATCH_label_a637;  /*opt-block+*/
17295                                               else 
17296                                                 goto MATCH_label_a636;  /*opt-block+*/
17297                                               
17298                                               break;
17299                                             case 5: 
17300                                               goto MATCH_label_a638; break;
17301                                             default: assert(0);
17302                                           } /* (MATCH_w_8_16 & 0x7) 
17303                                                 -- r_m at 16 --*/ 
17304                                         break;
17305                                       case 1: 
17306                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
17307                                         if ((MATCH_w_8_16 & 0x7) 
17308                                                 /* r_m at 16 */ == 4 && 
17309                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
17310                                                 /* index at 24 */ && 
17311                                           (MATCH_w_8_24 >> 3 & 0x7) 
17312                                                 /* index at 24 */ < 8)) { 
17313                                           unsigned Eaddr = 
17314                                             2 + addressToPC(MATCH_p);
17315                                           nextPC = 5 + MATCH_p; 
17316                                           
17317                                           #line 887 "machine/pentium/disassembler.m"
17318                                           
17319 
17320                                                   sprintf (str,  "IDIVAX", DIS_EADDR16);
17321 
17322                                           
17323 
17324                                           
17325                                           
17326                                           
17327                                         } /*opt-block*//*opt-block+*/
17328                                         else 
17329                                           goto MATCH_label_a636;  /*opt-block+*/
17330                                         
17331                                         break;
17332                                       case 2: 
17333                                         MATCH_w_8_24 = getByte(3 + MATCH_p); 
17334                                         if ((MATCH_w_8_16 & 0x7) 
17335                                                 /* r_m at 16 */ == 4 && 
17336                                           (0 <= (MATCH_w_8_24 >> 3 & 0x7) 
17337                                                 /* index at 24 */ && 
17338                                           (MATCH_w_8_24 >> 3 & 0x7) 
17339                                                 /* index at 24 */ < 8)) 
17340                                           goto MATCH_label_a637;  /*opt-block+*/
17341                                         else 
17342                                           goto MATCH_label_a638;  /*opt-block+*/
17343                                         
17344                                         break;
17345                                       case 3: 
17346                                         goto MATCH_label_a635; break;
17347                                       default: assert(0);
17348                                     } /* (MATCH_w_8_16 >> 6 & 0x3) 
17349                                           -- mod at 16 --*/ 
17350                                   break;
17351                                 default: assert(0);
17352                               } /* (MATCH_w_8_16 >> 3 & 0x7) 
17353                                     -- reg_opcode at 16 --*/ 
17354                             
17355                           } /*opt-block*/ 
17356                         else 
17357                           goto MATCH_label_a39;  /*opt-block+*/
17358                         break;
17359                       default: assert(0);
17360                     } /* (MATCH_w_8_8 >> 4 & 0xf) -- row at 8 --*/ 
17361                   
17362                 } /*opt-block*/
17363                 break;
17364               case 7: 
17365                 goto MATCH_label_a39; break;
17366               default: assert(0);
17367             } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
17368           break;
17369         case 7: 
17370           goto MATCH_label_a39; break;
17371         case 8: 
17372           if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) 
17373             
17374               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
17375                 case 0: 
17376                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
17377                   
17378                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
17379                       case 0: 
17380                         
17381                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
17382                             case 0: case 1: case 2: case 3: case 6: case 7: 
17383                               goto MATCH_label_a763; break;
17384                             case 4: 
17385                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
17386                               if ((MATCH_w_8_16 & 0x7) 
17387                                       /* base at 16 */ == 5 && 
17388                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17389                                       /* index at 16 */ && 
17390                                 (MATCH_w_8_16 >> 3 & 0x7) 
17391                                       /* index at 16 */ < 8)) 
17392                                 goto MATCH_label_a765;  /*opt-block+*/
17393                               else 
17394                                 goto MATCH_label_a764;  /*opt-block+*/
17395                               
17396                               break;
17397                             case 5: 
17398                               goto MATCH_label_a766; break;
17399                             default: assert(0);
17400                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
17401                         break;
17402                       case 1: 
17403                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
17404                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
17405                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17406                                 /* index at 16 */ && 
17407                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
17408                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
17409                           unsigned reg = 
17410                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
17411                           nextPC = 4 + MATCH_p; 
17412                           
17413                           #line 742 "machine/pentium/disassembler.m"
17414                           
17415 
17416                                   sprintf (str,  "MOVmrb", DIS_EADDR8, DIS_REG8);
17417 
17418                           
17419 
17420                           
17421                           
17422                           
17423                         } /*opt-block*//*opt-block+*/
17424                         else 
17425                           goto MATCH_label_a764;  /*opt-block+*/
17426                         
17427                         break;
17428                       case 2: 
17429                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
17430                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
17431                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17432                                 /* index at 16 */ && 
17433                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
17434                           goto MATCH_label_a765;  /*opt-block+*/
17435                         else 
17436                           goto MATCH_label_a766;  /*opt-block+*/
17437                         
17438                         break;
17439                       case 3: 
17440                         goto MATCH_label_a763; break;
17441                       default: assert(0);
17442                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
17443                   
17444                   break;
17445                 case 1: 
17446                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
17447                   
17448                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
17449                       case 0: 
17450                         
17451                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
17452                             case 0: case 1: case 2: case 3: case 6: case 7: 
17453                               goto MATCH_label_a767; break;
17454                             case 4: 
17455                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
17456                               if ((MATCH_w_8_16 & 0x7) 
17457                                       /* base at 16 */ == 5 && 
17458                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17459                                       /* index at 16 */ && 
17460                                 (MATCH_w_8_16 >> 3 & 0x7) 
17461                                       /* index at 16 */ < 8)) 
17462                                 goto MATCH_label_a769;  /*opt-block+*/
17463                               else 
17464                                 goto MATCH_label_a768;  /*opt-block+*/
17465                               
17466                               break;
17467                             case 5: 
17468                               goto MATCH_label_a770; break;
17469                             default: assert(0);
17470                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
17471                         break;
17472                       case 1: 
17473                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
17474                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
17475                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17476                                 /* index at 16 */ && 
17477                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
17478                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
17479                           unsigned reg = 
17480                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
17481                           nextPC = 4 + MATCH_p; 
17482                           
17483                           #line 736 "machine/pentium/disassembler.m"
17484                           
17485 
17486                                   sprintf (str,  "MOVmrod", DIS_EADDR32, DIS_REG32);
17487 
17488                           
17489 
17490                           
17491                           
17492                           
17493                         } /*opt-block*//*opt-block+*/
17494                         else 
17495                           goto MATCH_label_a768;  /*opt-block+*/
17496                         
17497                         break;
17498                       case 2: 
17499                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
17500                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
17501                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17502                                 /* index at 16 */ && 
17503                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
17504                           goto MATCH_label_a769;  /*opt-block+*/
17505                         else 
17506                           goto MATCH_label_a770;  /*opt-block+*/
17507                         
17508                         break;
17509                       case 3: 
17510                         goto MATCH_label_a767; break;
17511                       default: assert(0);
17512                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
17513                   
17514                   break;
17515                 case 2: 
17516                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
17517                   
17518                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
17519                       case 0: 
17520                         
17521                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
17522                             case 0: case 1: case 2: case 3: case 6: case 7: 
17523                               goto MATCH_label_a771; break;
17524                             case 4: 
17525                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
17526                               if ((MATCH_w_8_16 & 0x7) 
17527                                       /* base at 16 */ == 5 && 
17528                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17529                                       /* index at 16 */ && 
17530                                 (MATCH_w_8_16 >> 3 & 0x7) 
17531                                       /* index at 16 */ < 8)) 
17532                                 goto MATCH_label_a773;  /*opt-block+*/
17533                               else 
17534                                 goto MATCH_label_a772;  /*opt-block+*/
17535                               
17536                               break;
17537                             case 5: 
17538                               goto MATCH_label_a774; break;
17539                             default: assert(0);
17540                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
17541                         break;
17542                       case 1: 
17543                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
17544                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
17545                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17546                                 /* index at 16 */ && 
17547                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
17548                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
17549                           unsigned reg = 
17550                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
17551                           nextPC = 4 + MATCH_p; 
17552                           
17553                           #line 733 "machine/pentium/disassembler.m"
17554                           
17555 
17556                                   sprintf (str,  "MOVrmb", DIS_REG8, DIS_EADDR8);
17557 
17558                           
17559 
17560                           
17561                           
17562                           
17563                         } /*opt-block*//*opt-block+*/
17564                         else 
17565                           goto MATCH_label_a772;  /*opt-block+*/
17566                         
17567                         break;
17568                       case 2: 
17569                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
17570                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
17571                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17572                                 /* index at 16 */ && 
17573                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
17574                           goto MATCH_label_a773;  /*opt-block+*/
17575                         else 
17576                           goto MATCH_label_a774;  /*opt-block+*/
17577                         
17578                         break;
17579                       case 3: 
17580                         goto MATCH_label_a771; break;
17581                       default: assert(0);
17582                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
17583                   
17584                   break;
17585                 case 3: 
17586                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
17587                   
17588                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
17589                       case 0: 
17590                         
17591                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
17592                             case 0: case 1: case 2: case 3: case 6: case 7: 
17593                               goto MATCH_label_a775; break;
17594                             case 4: 
17595                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
17596                               if ((MATCH_w_8_16 & 0x7) 
17597                                       /* base at 16 */ == 5 && 
17598                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17599                                       /* index at 16 */ && 
17600                                 (MATCH_w_8_16 >> 3 & 0x7) 
17601                                       /* index at 16 */ < 8)) 
17602                                 goto MATCH_label_a777;  /*opt-block+*/
17603                               else 
17604                                 goto MATCH_label_a776;  /*opt-block+*/
17605                               
17606                               break;
17607                             case 5: 
17608                               goto MATCH_label_a778; break;
17609                             default: assert(0);
17610                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
17611                         break;
17612                       case 1: 
17613                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
17614                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
17615                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17616                                 /* index at 16 */ && 
17617                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
17618                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
17619                           unsigned reg = 
17620                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
17621                           nextPC = 4 + MATCH_p; 
17622                           
17623                           #line 727 "machine/pentium/disassembler.m"
17624                           
17625 
17626                                   sprintf (str,  "MOVrmod", DIS_REG32, DIS_EADDR32);
17627 
17628                           
17629 
17630                           
17631                           
17632                           
17633                         } /*opt-block*//*opt-block+*/
17634                         else 
17635                           goto MATCH_label_a776;  /*opt-block+*/
17636                         
17637                         break;
17638                       case 2: 
17639                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
17640                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
17641                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17642                                 /* index at 16 */ && 
17643                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
17644                           goto MATCH_label_a777;  /*opt-block+*/
17645                         else 
17646                           goto MATCH_label_a778;  /*opt-block+*/
17647                         
17648                         break;
17649                       case 3: 
17650                         goto MATCH_label_a775; break;
17651                       default: assert(0);
17652                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
17653                   
17654                   break;
17655                 case 4: case 6: 
17656                   goto MATCH_label_a39; break;
17657                 case 5: 
17658                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
17659                   
17660                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
17661                       case 0: 
17662                         
17663                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
17664                             case 0: case 1: case 2: case 3: case 6: case 7: 
17665                               { 
17666                                 unsigned Mem = 1 + addressToPC(MATCH_p);
17667                                 unsigned reg = 
17668                                   (MATCH_w_8_8 >> 3 & 0x7) 
17669                                         /* reg_opcode at 8 */;
17670                                 nextPC = 2 + MATCH_p; 
17671                                 
17672                                 #line 778 "machine/pentium/disassembler.m"
17673                                 
17674 
17675                                         sprintf (str,  "LEA.od", DIS_REG32, DIS_MEM);
17676 
17677                                 
17678 
17679                                 
17680                                 
17681                                 
17682                               }
17683                               
17684                               break;
17685                             case 4: 
17686                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
17687                               if ((MATCH_w_8_16 & 0x7) 
17688                                       /* base at 16 */ == 5 && 
17689                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17690                                       /* index at 16 */ && 
17691                                 (MATCH_w_8_16 >> 3 & 0x7) 
17692                                       /* index at 16 */ < 8)) 
17693                                 goto MATCH_label_a780;  /*opt-block+*/
17694                               else 
17695                                 goto MATCH_label_a779;  /*opt-block+*/
17696                               
17697                               break;
17698                             case 5: 
17699                               goto MATCH_label_a781; break;
17700                             default: assert(0);
17701                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
17702                         break;
17703                       case 1: 
17704                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
17705                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
17706                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17707                                 /* index at 16 */ && 
17708                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
17709                           unsigned Mem = 1 + addressToPC(MATCH_p);
17710                           unsigned reg = 
17711                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
17712                           nextPC = 4 + MATCH_p; 
17713                           
17714                           #line 778 "machine/pentium/disassembler.m"
17715                           
17716 
17717                                   sprintf (str,  "LEA.od", DIS_REG32, DIS_MEM);
17718 
17719                           
17720 
17721                           
17722                           
17723                           
17724                         } /*opt-block*//*opt-block+*/
17725                         else 
17726                           goto MATCH_label_a779;  /*opt-block+*/
17727                         
17728                         break;
17729                       case 2: 
17730                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
17731                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
17732                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17733                                 /* index at 16 */ && 
17734                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
17735                           goto MATCH_label_a780;  /*opt-block+*/
17736                         else 
17737                           goto MATCH_label_a781;  /*opt-block+*/
17738                         
17739                         break;
17740                       case 3: 
17741                         goto MATCH_label_a39; break;
17742                       default: assert(0);
17743                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
17744                   
17745                   break;
17746                 case 7: 
17747                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
17748                   if ((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */ == 0) 
17749                     
17750                       switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
17751                         case 0: 
17752                           
17753                             switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
17754                               case 0: case 1: case 2: case 3: case 6: case 7: 
17755                                 { 
17756                                   unsigned Mem = 1 + addressToPC(MATCH_p);
17757                                   nextPC = 2 + MATCH_p; 
17758                                   
17759                                   #line 582 "machine/pentium/disassembler.m"
17760                                   
17761 
17762                                           sprintf (str,  "POP.Evod", DIS_MEM);
17763 
17764                                   
17765 
17766                                   
17767                                   
17768                                   
17769                                 }
17770                                 
17771                                 break;
17772                               case 4: 
17773                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
17774                                 if ((MATCH_w_8_16 & 0x7) 
17775                                         /* base at 16 */ == 5 && 
17776                                   (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17777                                         /* index at 16 */ && 
17778                                   (MATCH_w_8_16 >> 3 & 0x7) 
17779                                         /* index at 16 */ < 8)) 
17780                                   goto MATCH_label_a783;  /*opt-block+*/
17781                                 else 
17782                                   goto MATCH_label_a782;  /*opt-block+*/
17783                                 
17784                                 break;
17785                               case 5: 
17786                                 goto MATCH_label_a784; break;
17787                               default: assert(0);
17788                             } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
17789                           break;
17790                         case 1: 
17791                           MATCH_w_8_16 = getByte(2 + MATCH_p); 
17792                           if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
17793                             (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17794                                   /* index at 16 */ && 
17795                             (MATCH_w_8_16 >> 3 & 0x7) 
17796                                   /* index at 16 */ < 8)) { 
17797                             unsigned Mem = 1 + addressToPC(MATCH_p);
17798                             nextPC = 4 + MATCH_p; 
17799                             
17800                             #line 582 "machine/pentium/disassembler.m"
17801                             
17802 
17803                                     sprintf (str,  "POP.Evod", DIS_MEM);
17804 
17805                             
17806 
17807                             
17808                             
17809                             
17810                           } /*opt-block*//*opt-block+*/
17811                           else 
17812                             goto MATCH_label_a782;  /*opt-block+*/
17813                           
17814                           break;
17815                         case 2: 
17816                           MATCH_w_8_16 = getByte(2 + MATCH_p); 
17817                           if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
17818                             (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17819                                   /* index at 16 */ && 
17820                             (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
17821                             goto MATCH_label_a783;  /*opt-block+*/
17822                           else 
17823                             goto MATCH_label_a784;  /*opt-block+*/
17824                           
17825                           break;
17826                         case 3: 
17827                           goto MATCH_label_a39; break;
17828                         default: assert(0);
17829                       } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/  
17830                   else 
17831                     goto MATCH_label_a39;  /*opt-block+*/
17832                   
17833                   break;
17834                 default: assert(0);
17835               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/  
17836           else 
17837             
17838               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
17839                 case 0: 
17840                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
17841                   
17842                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
17843                       case 0: 
17844                         
17845                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
17846                             case 0: 
17847                               
17848                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
17849                                   case 0: case 1: case 2: case 3: case 6: 
17850                                   case 7: 
17851                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
17852                                     goto MATCH_label_a651; 
17853                                     
17854                                     break;
17855                                   case 4: 
17856                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
17857                                     if ((MATCH_w_8_16 & 0x7) 
17858                                             /* base at 16 */ == 5 && 
17859                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17860                                             /* index at 16 */ && 
17861                                       (MATCH_w_8_16 >> 3 & 0x7) 
17862                                             /* index at 16 */ < 8)) { 
17863                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
17864                                       goto MATCH_label_a653; 
17865                                       
17866                                     } /*opt-block*/
17867                                     else { 
17868                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
17869                                       goto MATCH_label_a652; 
17870                                       
17871                                     } /*opt-block*/
17872                                     
17873                                     break;
17874                                   case 5: 
17875                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
17876                                     goto MATCH_label_a654; 
17877                                     
17878                                     break;
17879                                   default: assert(0);
17880                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
17881                               break;
17882                             case 1: 
17883                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
17884                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
17885                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17886                                       /* index at 16 */ && 
17887                                 (MATCH_w_8_16 >> 3 & 0x7) 
17888                                       /* index at 16 */ < 8)) { 
17889                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
17890                                 { 
17891                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
17892                                   int /* [~128..127] */ i8 = 
17893                                     sign_extend(
17894                                                 (MATCH_w_8_32 & 0xff) 
17895                                                       /* i8 at 32 */, 8);
17896                                   nextPC = 5 + MATCH_p; 
17897                                   
17898                                   #line 1339 "machine/pentium/disassembler.m"
17899                                   
17900 
17901                                           sprintf (str,  "ADDib", DIS_EADDR8, DIS_I8);
17902 
17903                                   
17904 
17905                                   
17906                                   
17907                                   
17908                                 }
17909                                 
17910                               } /*opt-block*/
17911                               else { 
17912                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
17913                                 goto MATCH_label_a652; 
17914                                 
17915                               } /*opt-block*/
17916                               
17917                               break;
17918                             case 2: 
17919                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
17920                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
17921                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17922                                       /* index at 16 */ && 
17923                                 (MATCH_w_8_16 >> 3 & 0x7) 
17924                                       /* index at 16 */ < 8)) { 
17925                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
17926                                 goto MATCH_label_a653; 
17927                                 
17928                               } /*opt-block*/
17929                               else { 
17930                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
17931                                 goto MATCH_label_a654; 
17932                                 
17933                               } /*opt-block*/
17934                               
17935                               break;
17936                             case 3: 
17937                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
17938                               goto MATCH_label_a651; 
17939                               
17940                               break;
17941                             default: assert(0);
17942                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
17943                         break;
17944                       case 1: 
17945                         
17946                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
17947                             case 0: 
17948                               
17949                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
17950                                   case 0: case 1: case 2: case 3: case 6: 
17951                                   case 7: 
17952                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
17953                                     goto MATCH_label_a655; 
17954                                     
17955                                     break;
17956                                   case 4: 
17957                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
17958                                     if ((MATCH_w_8_16 & 0x7) 
17959                                             /* base at 16 */ == 5 && 
17960                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17961                                             /* index at 16 */ && 
17962                                       (MATCH_w_8_16 >> 3 & 0x7) 
17963                                             /* index at 16 */ < 8)) { 
17964                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
17965                                       goto MATCH_label_a657; 
17966                                       
17967                                     } /*opt-block*/
17968                                     else { 
17969                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
17970                                       goto MATCH_label_a656; 
17971                                       
17972                                     } /*opt-block*/
17973                                     
17974                                     break;
17975                                   case 5: 
17976                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
17977                                     goto MATCH_label_a658; 
17978                                     
17979                                     break;
17980                                   default: assert(0);
17981                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
17982                               break;
17983                             case 1: 
17984                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
17985                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
17986                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
17987                                       /* index at 16 */ && 
17988                                 (MATCH_w_8_16 >> 3 & 0x7) 
17989                                       /* index at 16 */ < 8)) { 
17990                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
17991                                 { 
17992                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
17993                                   int /* [~128..127] */ i8 = 
17994                                     sign_extend(
17995                                                 (MATCH_w_8_32 & 0xff) 
17996                                                       /* i8 at 32 */, 8);
17997                                   nextPC = 5 + MATCH_p; 
17998                                   
17999                                   #line 1336 "machine/pentium/disassembler.m"
18000                                   
18001 
18002                                           sprintf (str,  "ORib", DIS_EADDR8, DIS_I8);
18003 
18004                                   
18005 
18006                                   
18007                                   
18008                                   
18009                                 }
18010                                 
18011                               } /*opt-block*/
18012                               else { 
18013                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
18014                                 goto MATCH_label_a656; 
18015                                 
18016                               } /*opt-block*/
18017                               
18018                               break;
18019                             case 2: 
18020                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18021                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18022                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18023                                       /* index at 16 */ && 
18024                                 (MATCH_w_8_16 >> 3 & 0x7) 
18025                                       /* index at 16 */ < 8)) { 
18026                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
18027                                 goto MATCH_label_a657; 
18028                                 
18029                               } /*opt-block*/
18030                               else { 
18031                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
18032                                 goto MATCH_label_a658; 
18033                                 
18034                               } /*opt-block*/
18035                               
18036                               break;
18037                             case 3: 
18038                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18039                               goto MATCH_label_a655; 
18040                               
18041                               break;
18042                             default: assert(0);
18043                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
18044                         break;
18045                       case 2: 
18046                         
18047                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
18048                             case 0: 
18049                               
18050                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
18051                                   case 0: case 1: case 2: case 3: case 6: 
18052                                   case 7: 
18053                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
18054                                     goto MATCH_label_a659; 
18055                                     
18056                                     break;
18057                                   case 4: 
18058                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
18059                                     if ((MATCH_w_8_16 & 0x7) 
18060                                             /* base at 16 */ == 5 && 
18061                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18062                                             /* index at 16 */ && 
18063                                       (MATCH_w_8_16 >> 3 & 0x7) 
18064                                             /* index at 16 */ < 8)) { 
18065                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
18066                                       goto MATCH_label_a661; 
18067                                       
18068                                     } /*opt-block*/
18069                                     else { 
18070                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
18071                                       goto MATCH_label_a660; 
18072                                       
18073                                     } /*opt-block*/
18074                                     
18075                                     break;
18076                                   case 5: 
18077                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
18078                                     goto MATCH_label_a662; 
18079                                     
18080                                     break;
18081                                   default: assert(0);
18082                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
18083                               break;
18084                             case 1: 
18085                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18086                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18087                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18088                                       /* index at 16 */ && 
18089                                 (MATCH_w_8_16 >> 3 & 0x7) 
18090                                       /* index at 16 */ < 8)) { 
18091                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
18092                                 { 
18093                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
18094                                   int /* [~128..127] */ i8 = 
18095                                     sign_extend(
18096                                                 (MATCH_w_8_32 & 0xff) 
18097                                                       /* i8 at 32 */, 8);
18098                                   nextPC = 5 + MATCH_p; 
18099                                   
18100                                   #line 1333 "machine/pentium/disassembler.m"
18101                                   
18102 
18103                                           sprintf (str,  "ADCib", DIS_EADDR8, DIS_I8);
18104 
18105                                   
18106 
18107                                   
18108                                   
18109                                   
18110                                 }
18111                                 
18112                               } /*opt-block*/
18113                               else { 
18114                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
18115                                 goto MATCH_label_a660; 
18116                                 
18117                               } /*opt-block*/
18118                               
18119                               break;
18120                             case 2: 
18121                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18122                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18123                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18124                                       /* index at 16 */ && 
18125                                 (MATCH_w_8_16 >> 3 & 0x7) 
18126                                       /* index at 16 */ < 8)) { 
18127                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
18128                                 goto MATCH_label_a661; 
18129                                 
18130                               } /*opt-block*/
18131                               else { 
18132                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
18133                                 goto MATCH_label_a662; 
18134                                 
18135                               } /*opt-block*/
18136                               
18137                               break;
18138                             case 3: 
18139                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18140                               goto MATCH_label_a659; 
18141                               
18142                               break;
18143                             default: assert(0);
18144                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
18145                         break;
18146                       case 3: 
18147                         
18148                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
18149                             case 0: 
18150                               
18151                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
18152                                   case 0: case 1: case 2: case 3: case 6: 
18153                                   case 7: 
18154                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
18155                                     goto MATCH_label_a663; 
18156                                     
18157                                     break;
18158                                   case 4: 
18159                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
18160                                     if ((MATCH_w_8_16 & 0x7) 
18161                                             /* base at 16 */ == 5 && 
18162                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18163                                             /* index at 16 */ && 
18164                                       (MATCH_w_8_16 >> 3 & 0x7) 
18165                                             /* index at 16 */ < 8)) { 
18166                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
18167                                       goto MATCH_label_a665; 
18168                                       
18169                                     } /*opt-block*/
18170                                     else { 
18171                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
18172                                       goto MATCH_label_a664; 
18173                                       
18174                                     } /*opt-block*/
18175                                     
18176                                     break;
18177                                   case 5: 
18178                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
18179                                     goto MATCH_label_a666; 
18180                                     
18181                                     break;
18182                                   default: assert(0);
18183                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
18184                               break;
18185                             case 1: 
18186                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18187                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18188                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18189                                       /* index at 16 */ && 
18190                                 (MATCH_w_8_16 >> 3 & 0x7) 
18191                                       /* index at 16 */ < 8)) { 
18192                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
18193                                 { 
18194                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
18195                                   int /* [~128..127] */ i8 = 
18196                                     sign_extend(
18197                                                 (MATCH_w_8_32 & 0xff) 
18198                                                       /* i8 at 32 */, 8);
18199                                   nextPC = 5 + MATCH_p; 
18200                                   
18201                                   #line 1330 "machine/pentium/disassembler.m"
18202                                   
18203 
18204                                           sprintf (str,  "SBBib", DIS_EADDR8, DIS_I8);
18205 
18206                                   
18207 
18208                                   
18209                                   
18210                                   
18211                                 }
18212                                 
18213                               } /*opt-block*/
18214                               else { 
18215                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
18216                                 goto MATCH_label_a664; 
18217                                 
18218                               } /*opt-block*/
18219                               
18220                               break;
18221                             case 2: 
18222                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18223                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18224                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18225                                       /* index at 16 */ && 
18226                                 (MATCH_w_8_16 >> 3 & 0x7) 
18227                                       /* index at 16 */ < 8)) { 
18228                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
18229                                 goto MATCH_label_a665; 
18230                                 
18231                               } /*opt-block*/
18232                               else { 
18233                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
18234                                 goto MATCH_label_a666; 
18235                                 
18236                               } /*opt-block*/
18237                               
18238                               break;
18239                             case 3: 
18240                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18241                               goto MATCH_label_a663; 
18242                               
18243                               break;
18244                             default: assert(0);
18245                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
18246                         break;
18247                       case 4: 
18248                         
18249                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
18250                             case 0: 
18251                               
18252                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
18253                                   case 0: case 1: case 2: case 3: case 6: 
18254                                   case 7: 
18255                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
18256                                     goto MATCH_label_a667; 
18257                                     
18258                                     break;
18259                                   case 4: 
18260                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
18261                                     if ((MATCH_w_8_16 & 0x7) 
18262                                             /* base at 16 */ == 5 && 
18263                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18264                                             /* index at 16 */ && 
18265                                       (MATCH_w_8_16 >> 3 & 0x7) 
18266                                             /* index at 16 */ < 8)) { 
18267                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
18268                                       goto MATCH_label_a669; 
18269                                       
18270                                     } /*opt-block*/
18271                                     else { 
18272                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
18273                                       goto MATCH_label_a668; 
18274                                       
18275                                     } /*opt-block*/
18276                                     
18277                                     break;
18278                                   case 5: 
18279                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
18280                                     goto MATCH_label_a670; 
18281                                     
18282                                     break;
18283                                   default: assert(0);
18284                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
18285                               break;
18286                             case 1: 
18287                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18288                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18289                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18290                                       /* index at 16 */ && 
18291                                 (MATCH_w_8_16 >> 3 & 0x7) 
18292                                       /* index at 16 */ < 8)) { 
18293                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
18294                                 { 
18295                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
18296                                   int /* [~128..127] */ i8 = 
18297                                     sign_extend(
18298                                                 (MATCH_w_8_32 & 0xff) 
18299                                                       /* i8 at 32 */, 8);
18300                                   nextPC = 5 + MATCH_p; 
18301                                   
18302                                   #line 1327 "machine/pentium/disassembler.m"
18303                                   
18304 
18305                                           sprintf (str,  "ANDib", DIS_EADDR8, DIS_I8);
18306 
18307                                   
18308 
18309                                   
18310                                   
18311                                   
18312                                 }
18313                                 
18314                               } /*opt-block*/
18315                               else { 
18316                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
18317                                 goto MATCH_label_a668; 
18318                                 
18319                               } /*opt-block*/
18320                               
18321                               break;
18322                             case 2: 
18323                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18324                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18325                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18326                                       /* index at 16 */ && 
18327                                 (MATCH_w_8_16 >> 3 & 0x7) 
18328                                       /* index at 16 */ < 8)) { 
18329                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
18330                                 goto MATCH_label_a669; 
18331                                 
18332                               } /*opt-block*/
18333                               else { 
18334                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
18335                                 goto MATCH_label_a670; 
18336                                 
18337                               } /*opt-block*/
18338                               
18339                               break;
18340                             case 3: 
18341                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18342                               goto MATCH_label_a667; 
18343                               
18344                               break;
18345                             default: assert(0);
18346                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
18347                         break;
18348                       case 5: 
18349                         
18350                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
18351                             case 0: 
18352                               
18353                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
18354                                   case 0: case 1: case 2: case 3: case 6: 
18355                                   case 7: 
18356                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
18357                                     goto MATCH_label_a671; 
18358                                     
18359                                     break;
18360                                   case 4: 
18361                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
18362                                     if ((MATCH_w_8_16 & 0x7) 
18363                                             /* base at 16 */ == 5 && 
18364                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18365                                             /* index at 16 */ && 
18366                                       (MATCH_w_8_16 >> 3 & 0x7) 
18367                                             /* index at 16 */ < 8)) { 
18368                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
18369                                       goto MATCH_label_a673; 
18370                                       
18371                                     } /*opt-block*/
18372                                     else { 
18373                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
18374                                       goto MATCH_label_a672; 
18375                                       
18376                                     } /*opt-block*/
18377                                     
18378                                     break;
18379                                   case 5: 
18380                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
18381                                     goto MATCH_label_a674; 
18382                                     
18383                                     break;
18384                                   default: assert(0);
18385                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
18386                               break;
18387                             case 1: 
18388                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18389                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18390                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18391                                       /* index at 16 */ && 
18392                                 (MATCH_w_8_16 >> 3 & 0x7) 
18393                                       /* index at 16 */ < 8)) { 
18394                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
18395                                 { 
18396                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
18397                                   int /* [~128..127] */ i8 = 
18398                                     sign_extend(
18399                                                 (MATCH_w_8_32 & 0xff) 
18400                                                       /* i8 at 32 */, 8);
18401                                   nextPC = 5 + MATCH_p; 
18402                                   
18403                                   #line 1324 "machine/pentium/disassembler.m"
18404                                   
18405 
18406                                           sprintf (str,  "SUBib", DIS_EADDR8, DIS_I8);
18407 
18408                                   
18409 
18410                                   
18411                                   
18412                                   
18413                                 }
18414                                 
18415                               } /*opt-block*/
18416                               else { 
18417                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
18418                                 goto MATCH_label_a672; 
18419                                 
18420                               } /*opt-block*/
18421                               
18422                               break;
18423                             case 2: 
18424                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18425                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18426                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18427                                       /* index at 16 */ && 
18428                                 (MATCH_w_8_16 >> 3 & 0x7) 
18429                                       /* index at 16 */ < 8)) { 
18430                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
18431                                 goto MATCH_label_a673; 
18432                                 
18433                               } /*opt-block*/
18434                               else { 
18435                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
18436                                 goto MATCH_label_a674; 
18437                                 
18438                               } /*opt-block*/
18439                               
18440                               break;
18441                             case 3: 
18442                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18443                               goto MATCH_label_a671; 
18444                               
18445                               break;
18446                             default: assert(0);
18447                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
18448                         break;
18449                       case 6: 
18450                         
18451                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
18452                             case 0: 
18453                               
18454                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
18455                                   case 0: case 1: case 2: case 3: case 6: 
18456                                   case 7: 
18457                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
18458                                     goto MATCH_label_a675; 
18459                                     
18460                                     break;
18461                                   case 4: 
18462                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
18463                                     if ((MATCH_w_8_16 & 0x7) 
18464                                             /* base at 16 */ == 5 && 
18465                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18466                                             /* index at 16 */ && 
18467                                       (MATCH_w_8_16 >> 3 & 0x7) 
18468                                             /* index at 16 */ < 8)) { 
18469                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
18470                                       goto MATCH_label_a677; 
18471                                       
18472                                     } /*opt-block*/
18473                                     else { 
18474                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
18475                                       goto MATCH_label_a676; 
18476                                       
18477                                     } /*opt-block*/
18478                                     
18479                                     break;
18480                                   case 5: 
18481                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
18482                                     goto MATCH_label_a678; 
18483                                     
18484                                     break;
18485                                   default: assert(0);
18486                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
18487                               break;
18488                             case 1: 
18489                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18490                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18491                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18492                                       /* index at 16 */ && 
18493                                 (MATCH_w_8_16 >> 3 & 0x7) 
18494                                       /* index at 16 */ < 8)) { 
18495                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
18496                                 { 
18497                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
18498                                   int /* [~128..127] */ i8 = 
18499                                     sign_extend(
18500                                                 (MATCH_w_8_32 & 0xff) 
18501                                                       /* i8 at 32 */, 8);
18502                                   nextPC = 5 + MATCH_p; 
18503                                   
18504                                   #line 1321 "machine/pentium/disassembler.m"
18505                                   
18506 
18507                                           sprintf (str,  "XORib", DIS_EADDR8, DIS_I8);
18508 
18509                                   
18510 
18511                                   
18512                                   
18513                                   
18514                                 }
18515                                 
18516                               } /*opt-block*/
18517                               else { 
18518                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
18519                                 goto MATCH_label_a676; 
18520                                 
18521                               } /*opt-block*/
18522                               
18523                               break;
18524                             case 2: 
18525                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18526                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18527                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18528                                       /* index at 16 */ && 
18529                                 (MATCH_w_8_16 >> 3 & 0x7) 
18530                                       /* index at 16 */ < 8)) { 
18531                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
18532                                 goto MATCH_label_a677; 
18533                                 
18534                               } /*opt-block*/
18535                               else { 
18536                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
18537                                 goto MATCH_label_a678; 
18538                                 
18539                               } /*opt-block*/
18540                               
18541                               break;
18542                             case 3: 
18543                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18544                               goto MATCH_label_a675; 
18545                               
18546                               break;
18547                             default: assert(0);
18548                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
18549                         break;
18550                       case 7: 
18551                         
18552                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
18553                             case 0: 
18554                               
18555                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
18556                                   case 0: case 1: case 2: case 3: case 6: 
18557                                   case 7: 
18558                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
18559                                     goto MATCH_label_a679; 
18560                                     
18561                                     break;
18562                                   case 4: 
18563                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
18564                                     if ((MATCH_w_8_16 & 0x7) 
18565                                             /* base at 16 */ == 5 && 
18566                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18567                                             /* index at 16 */ && 
18568                                       (MATCH_w_8_16 >> 3 & 0x7) 
18569                                             /* index at 16 */ < 8)) { 
18570                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
18571                                       goto MATCH_label_a681; 
18572                                       
18573                                     } /*opt-block*/
18574                                     else { 
18575                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
18576                                       goto MATCH_label_a680; 
18577                                       
18578                                     } /*opt-block*/
18579                                     
18580                                     break;
18581                                   case 5: 
18582                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
18583                                     goto MATCH_label_a682; 
18584                                     
18585                                     break;
18586                                   default: assert(0);
18587                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
18588                               break;
18589                             case 1: 
18590                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18591                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18592                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18593                                       /* index at 16 */ && 
18594                                 (MATCH_w_8_16 >> 3 & 0x7) 
18595                                       /* index at 16 */ < 8)) { 
18596                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
18597                                 { 
18598                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
18599                                   int /* [~128..127] */ i8 = 
18600                                     sign_extend(
18601                                                 (MATCH_w_8_32 & 0xff) 
18602                                                       /* i8 at 32 */, 8);
18603                                   nextPC = 5 + MATCH_p; 
18604                                   
18605                                   #line 1318 "machine/pentium/disassembler.m"
18606                                   
18607 
18608                                           sprintf (str,  "CMPib", DIS_EADDR8, DIS_I8);
18609 
18610                                   
18611 
18612                                   
18613                                   
18614                                   
18615                                 }
18616                                 
18617                               } /*opt-block*/
18618                               else { 
18619                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
18620                                 goto MATCH_label_a680; 
18621                                 
18622                               } /*opt-block*/
18623                               
18624                               break;
18625                             case 2: 
18626                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18627                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18628                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18629                                       /* index at 16 */ && 
18630                                 (MATCH_w_8_16 >> 3 & 0x7) 
18631                                       /* index at 16 */ < 8)) { 
18632                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
18633                                 goto MATCH_label_a681; 
18634                                 
18635                               } /*opt-block*/
18636                               else { 
18637                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
18638                                 goto MATCH_label_a682; 
18639                                 
18640                               } /*opt-block*/
18641                               
18642                               break;
18643                             case 3: 
18644                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18645                               goto MATCH_label_a679; 
18646                               
18647                               break;
18648                             default: assert(0);
18649                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
18650                         break;
18651                       default: assert(0);
18652                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
18653                   
18654                   break;
18655                 case 1: 
18656                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
18657                   
18658                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
18659                       case 0: 
18660                         
18661                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
18662                             case 0: 
18663                               
18664                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
18665                                   case 0: case 1: case 2: case 3: case 6: 
18666                                   case 7: 
18667                                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
18668                                     goto MATCH_label_a683; 
18669                                     
18670                                     break;
18671                                   case 4: 
18672                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
18673                                     if ((MATCH_w_8_16 & 0x7) 
18674                                             /* base at 16 */ == 5 && 
18675                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18676                                             /* index at 16 */ && 
18677                                       (MATCH_w_8_16 >> 3 & 0x7) 
18678                                             /* index at 16 */ < 8)) { 
18679                                       MATCH_w_32_56 = getDword(7 + MATCH_p); 
18680                                       goto MATCH_label_a685; 
18681                                       
18682                                     } /*opt-block*/
18683                                     else { 
18684                                       MATCH_w_32_24 = getDword(3 + MATCH_p); 
18685                                       goto MATCH_label_a684; 
18686                                       
18687                                     } /*opt-block*/
18688                                     
18689                                     break;
18690                                   case 5: 
18691                                     MATCH_w_32_48 = getDword(6 + MATCH_p); 
18692                                     goto MATCH_label_a686; 
18693                                     
18694                                     break;
18695                                   default: assert(0);
18696                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
18697                               break;
18698                             case 1: 
18699                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18700                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18701                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18702                                       /* index at 16 */ && 
18703                                 (MATCH_w_8_16 >> 3 & 0x7) 
18704                                       /* index at 16 */ < 8)) { 
18705                                 MATCH_w_32_32 = getDword(4 + MATCH_p); 
18706                                 { 
18707                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
18708                                   unsigned i32 = 
18709                                     MATCH_w_32_32 /* i32 at 32 */;
18710                                   nextPC = 8 + MATCH_p; 
18711                                   
18712                                   #line 1291 "machine/pentium/disassembler.m"
18713                                   
18714 
18715                                           sprintf (str,  "ADDid", DIS_EADDR32, DIS_I32);
18716 
18717                                   
18718 
18719                                   
18720                                   
18721                                   
18722                                 }
18723                                 
18724                               } /*opt-block*/
18725                               else { 
18726                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
18727                                 goto MATCH_label_a684; 
18728                                 
18729                               } /*opt-block*/
18730                               
18731                               break;
18732                             case 2: 
18733                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18734                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18735                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18736                                       /* index at 16 */ && 
18737                                 (MATCH_w_8_16 >> 3 & 0x7) 
18738                                       /* index at 16 */ < 8)) { 
18739                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
18740                                 goto MATCH_label_a685; 
18741                                 
18742                               } /*opt-block*/
18743                               else { 
18744                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
18745                                 goto MATCH_label_a686; 
18746                                 
18747                               } /*opt-block*/
18748                               
18749                               break;
18750                             case 3: 
18751                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
18752                               goto MATCH_label_a683; 
18753                               
18754                               break;
18755                             default: assert(0);
18756                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
18757                         break;
18758                       case 1: 
18759                         
18760                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
18761                             case 0: 
18762                               
18763                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
18764                                   case 0: case 1: case 2: case 3: case 6: 
18765                                   case 7: 
18766                                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
18767                                     goto MATCH_label_a687; 
18768                                     
18769                                     break;
18770                                   case 4: 
18771                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
18772                                     if ((MATCH_w_8_16 & 0x7) 
18773                                             /* base at 16 */ == 5 && 
18774                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18775                                             /* index at 16 */ && 
18776                                       (MATCH_w_8_16 >> 3 & 0x7) 
18777                                             /* index at 16 */ < 8)) { 
18778                                       MATCH_w_32_56 = getDword(7 + MATCH_p); 
18779                                       goto MATCH_label_a689; 
18780                                       
18781                                     } /*opt-block*/
18782                                     else { 
18783                                       MATCH_w_32_24 = getDword(3 + MATCH_p); 
18784                                       goto MATCH_label_a688; 
18785                                       
18786                                     } /*opt-block*/
18787                                     
18788                                     break;
18789                                   case 5: 
18790                                     MATCH_w_32_48 = getDword(6 + MATCH_p); 
18791                                     goto MATCH_label_a690; 
18792                                     
18793                                     break;
18794                                   default: assert(0);
18795                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
18796                               break;
18797                             case 1: 
18798                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18799                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18800                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18801                                       /* index at 16 */ && 
18802                                 (MATCH_w_8_16 >> 3 & 0x7) 
18803                                       /* index at 16 */ < 8)) { 
18804                                 MATCH_w_32_32 = getDword(4 + MATCH_p); 
18805                                 { 
18806                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
18807                                   unsigned i32 = 
18808                                     MATCH_w_32_32 /* i32 at 32 */;
18809                                   nextPC = 8 + MATCH_p; 
18810                                   
18811                                   #line 1288 "machine/pentium/disassembler.m"
18812                                   
18813 
18814                                           sprintf (str,  "ORid", DIS_EADDR32, DIS_I32);
18815 
18816                                   
18817 
18818                                   
18819                                   
18820                                   
18821                                 }
18822                                 
18823                               } /*opt-block*/
18824                               else { 
18825                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
18826                                 goto MATCH_label_a688; 
18827                                 
18828                               } /*opt-block*/
18829                               
18830                               break;
18831                             case 2: 
18832                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18833                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18834                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18835                                       /* index at 16 */ && 
18836                                 (MATCH_w_8_16 >> 3 & 0x7) 
18837                                       /* index at 16 */ < 8)) { 
18838                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
18839                                 goto MATCH_label_a689; 
18840                                 
18841                               } /*opt-block*/
18842                               else { 
18843                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
18844                                 goto MATCH_label_a690; 
18845                                 
18846                               } /*opt-block*/
18847                               
18848                               break;
18849                             case 3: 
18850                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
18851                               goto MATCH_label_a687; 
18852                               
18853                               break;
18854                             default: assert(0);
18855                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
18856                         break;
18857                       case 2: 
18858                         
18859                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
18860                             case 0: 
18861                               
18862                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
18863                                   case 0: case 1: case 2: case 3: case 6: 
18864                                   case 7: 
18865                                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
18866                                     goto MATCH_label_a691; 
18867                                     
18868                                     break;
18869                                   case 4: 
18870                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
18871                                     if ((MATCH_w_8_16 & 0x7) 
18872                                             /* base at 16 */ == 5 && 
18873                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18874                                             /* index at 16 */ && 
18875                                       (MATCH_w_8_16 >> 3 & 0x7) 
18876                                             /* index at 16 */ < 8)) { 
18877                                       MATCH_w_32_56 = getDword(7 + MATCH_p); 
18878                                       goto MATCH_label_a693; 
18879                                       
18880                                     } /*opt-block*/
18881                                     else { 
18882                                       MATCH_w_32_24 = getDword(3 + MATCH_p); 
18883                                       goto MATCH_label_a692; 
18884                                       
18885                                     } /*opt-block*/
18886                                     
18887                                     break;
18888                                   case 5: 
18889                                     MATCH_w_32_48 = getDword(6 + MATCH_p); 
18890                                     goto MATCH_label_a694; 
18891                                     
18892                                     break;
18893                                   default: assert(0);
18894                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
18895                               break;
18896                             case 1: 
18897                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18898                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18899                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18900                                       /* index at 16 */ && 
18901                                 (MATCH_w_8_16 >> 3 & 0x7) 
18902                                       /* index at 16 */ < 8)) { 
18903                                 MATCH_w_32_32 = getDword(4 + MATCH_p); 
18904                                 { 
18905                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
18906                                   unsigned i32 = 
18907                                     MATCH_w_32_32 /* i32 at 32 */;
18908                                   nextPC = 8 + MATCH_p; 
18909                                   
18910                                   #line 1285 "machine/pentium/disassembler.m"
18911                                   
18912 
18913                                           sprintf (str,  "ADCid", DIS_EADDR32, DIS_I32);
18914 
18915                                   
18916 
18917                                   
18918                                   
18919                                   
18920                                 }
18921                                 
18922                               } /*opt-block*/
18923                               else { 
18924                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
18925                                 goto MATCH_label_a692; 
18926                                 
18927                               } /*opt-block*/
18928                               
18929                               break;
18930                             case 2: 
18931                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18932                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18933                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18934                                       /* index at 16 */ && 
18935                                 (MATCH_w_8_16 >> 3 & 0x7) 
18936                                       /* index at 16 */ < 8)) { 
18937                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
18938                                 goto MATCH_label_a693; 
18939                                 
18940                               } /*opt-block*/
18941                               else { 
18942                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
18943                                 goto MATCH_label_a694; 
18944                                 
18945                               } /*opt-block*/
18946                               
18947                               break;
18948                             case 3: 
18949                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
18950                               goto MATCH_label_a691; 
18951                               
18952                               break;
18953                             default: assert(0);
18954                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
18955                         break;
18956                       case 3: 
18957                         
18958                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
18959                             case 0: 
18960                               
18961                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
18962                                   case 0: case 1: case 2: case 3: case 6: 
18963                                   case 7: 
18964                                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
18965                                     goto MATCH_label_a695; 
18966                                     
18967                                     break;
18968                                   case 4: 
18969                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
18970                                     if ((MATCH_w_8_16 & 0x7) 
18971                                             /* base at 16 */ == 5 && 
18972                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18973                                             /* index at 16 */ && 
18974                                       (MATCH_w_8_16 >> 3 & 0x7) 
18975                                             /* index at 16 */ < 8)) { 
18976                                       MATCH_w_32_56 = getDword(7 + MATCH_p); 
18977                                       goto MATCH_label_a697; 
18978                                       
18979                                     } /*opt-block*/
18980                                     else { 
18981                                       MATCH_w_32_24 = getDword(3 + MATCH_p); 
18982                                       goto MATCH_label_a696; 
18983                                       
18984                                     } /*opt-block*/
18985                                     
18986                                     break;
18987                                   case 5: 
18988                                     MATCH_w_32_48 = getDword(6 + MATCH_p); 
18989                                     goto MATCH_label_a698; 
18990                                     
18991                                     break;
18992                                   default: assert(0);
18993                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
18994                               break;
18995                             case 1: 
18996                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
18997                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
18998                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
18999                                       /* index at 16 */ && 
19000                                 (MATCH_w_8_16 >> 3 & 0x7) 
19001                                       /* index at 16 */ < 8)) { 
19002                                 MATCH_w_32_32 = getDword(4 + MATCH_p); 
19003                                 { 
19004                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
19005                                   unsigned i32 = 
19006                                     MATCH_w_32_32 /* i32 at 32 */;
19007                                   nextPC = 8 + MATCH_p; 
19008                                   
19009                                   #line 1282 "machine/pentium/disassembler.m"
19010                                   
19011 
19012                                           sprintf (str,  "SBBid", DIS_EADDR32, DIS_I32);
19013 
19014                                   
19015 
19016                                   
19017                                   
19018                                   
19019                                 }
19020                                 
19021                               } /*opt-block*/
19022                               else { 
19023                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
19024                                 goto MATCH_label_a696; 
19025                                 
19026                               } /*opt-block*/
19027                               
19028                               break;
19029                             case 2: 
19030                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19031                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
19032                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19033                                       /* index at 16 */ && 
19034                                 (MATCH_w_8_16 >> 3 & 0x7) 
19035                                       /* index at 16 */ < 8)) { 
19036                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
19037                                 goto MATCH_label_a697; 
19038                                 
19039                               } /*opt-block*/
19040                               else { 
19041                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
19042                                 goto MATCH_label_a698; 
19043                                 
19044                               } /*opt-block*/
19045                               
19046                               break;
19047                             case 3: 
19048                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
19049                               goto MATCH_label_a695; 
19050                               
19051                               break;
19052                             default: assert(0);
19053                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
19054                         break;
19055                       case 4: 
19056                         
19057                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
19058                             case 0: 
19059                               
19060                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
19061                                   case 0: case 1: case 2: case 3: case 6: 
19062                                   case 7: 
19063                                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
19064                                     goto MATCH_label_a699; 
19065                                     
19066                                     break;
19067                                   case 4: 
19068                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
19069                                     if ((MATCH_w_8_16 & 0x7) 
19070                                             /* base at 16 */ == 5 && 
19071                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19072                                             /* index at 16 */ && 
19073                                       (MATCH_w_8_16 >> 3 & 0x7) 
19074                                             /* index at 16 */ < 8)) { 
19075                                       MATCH_w_32_56 = getDword(7 + MATCH_p); 
19076                                       goto MATCH_label_a701; 
19077                                       
19078                                     } /*opt-block*/
19079                                     else { 
19080                                       MATCH_w_32_24 = getDword(3 + MATCH_p); 
19081                                       goto MATCH_label_a700; 
19082                                       
19083                                     } /*opt-block*/
19084                                     
19085                                     break;
19086                                   case 5: 
19087                                     MATCH_w_32_48 = getDword(6 + MATCH_p); 
19088                                     goto MATCH_label_a702; 
19089                                     
19090                                     break;
19091                                   default: assert(0);
19092                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
19093                               break;
19094                             case 1: 
19095                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19096                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
19097                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19098                                       /* index at 16 */ && 
19099                                 (MATCH_w_8_16 >> 3 & 0x7) 
19100                                       /* index at 16 */ < 8)) { 
19101                                 MATCH_w_32_32 = getDword(4 + MATCH_p); 
19102                                 { 
19103                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
19104                                   unsigned i32 = 
19105                                     MATCH_w_32_32 /* i32 at 32 */;
19106                                   nextPC = 8 + MATCH_p; 
19107                                   
19108                                   #line 1279 "machine/pentium/disassembler.m"
19109                                   
19110 
19111                                           sprintf (str,  "ANDid", DIS_EADDR32, DIS_I32);
19112 
19113                                   
19114 
19115                                   
19116                                   
19117                                   
19118                                 }
19119                                 
19120                               } /*opt-block*/
19121                               else { 
19122                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
19123                                 goto MATCH_label_a700; 
19124                                 
19125                               } /*opt-block*/
19126                               
19127                               break;
19128                             case 2: 
19129                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19130                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
19131                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19132                                       /* index at 16 */ && 
19133                                 (MATCH_w_8_16 >> 3 & 0x7) 
19134                                       /* index at 16 */ < 8)) { 
19135                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
19136                                 goto MATCH_label_a701; 
19137                                 
19138                               } /*opt-block*/
19139                               else { 
19140                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
19141                                 goto MATCH_label_a702; 
19142                                 
19143                               } /*opt-block*/
19144                               
19145                               break;
19146                             case 3: 
19147                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
19148                               goto MATCH_label_a699; 
19149                               
19150                               break;
19151                             default: assert(0);
19152                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
19153                         break;
19154                       case 5: 
19155                         
19156                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
19157                             case 0: 
19158                               
19159                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
19160                                   case 0: case 1: case 2: case 3: case 6: 
19161                                   case 7: 
19162                                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
19163                                     goto MATCH_label_a703; 
19164                                     
19165                                     break;
19166                                   case 4: 
19167                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
19168                                     if ((MATCH_w_8_16 & 0x7) 
19169                                             /* base at 16 */ == 5 && 
19170                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19171                                             /* index at 16 */ && 
19172                                       (MATCH_w_8_16 >> 3 & 0x7) 
19173                                             /* index at 16 */ < 8)) { 
19174                                       MATCH_w_32_56 = getDword(7 + MATCH_p); 
19175                                       goto MATCH_label_a705; 
19176                                       
19177                                     } /*opt-block*/
19178                                     else { 
19179                                       MATCH_w_32_24 = getDword(3 + MATCH_p); 
19180                                       goto MATCH_label_a704; 
19181                                       
19182                                     } /*opt-block*/
19183                                     
19184                                     break;
19185                                   case 5: 
19186                                     MATCH_w_32_48 = getDword(6 + MATCH_p); 
19187                                     goto MATCH_label_a706; 
19188                                     
19189                                     break;
19190                                   default: assert(0);
19191                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
19192                               break;
19193                             case 1: 
19194                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19195                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
19196                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19197                                       /* index at 16 */ && 
19198                                 (MATCH_w_8_16 >> 3 & 0x7) 
19199                                       /* index at 16 */ < 8)) { 
19200                                 MATCH_w_32_32 = getDword(4 + MATCH_p); 
19201                                 { 
19202                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
19203                                   unsigned i32 = 
19204                                     MATCH_w_32_32 /* i32 at 32 */;
19205                                   nextPC = 8 + MATCH_p; 
19206                                   
19207                                   #line 1276 "machine/pentium/disassembler.m"
19208                                   
19209 
19210                                           sprintf (str,  "SUBid", DIS_EADDR32, DIS_I32);
19211 
19212                                   
19213 
19214                                   
19215                                   
19216                                   
19217                                 }
19218                                 
19219                               } /*opt-block*/
19220                               else { 
19221                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
19222                                 goto MATCH_label_a704; 
19223                                 
19224                               } /*opt-block*/
19225                               
19226                               break;
19227                             case 2: 
19228                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19229                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
19230                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19231                                       /* index at 16 */ && 
19232                                 (MATCH_w_8_16 >> 3 & 0x7) 
19233                                       /* index at 16 */ < 8)) { 
19234                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
19235                                 goto MATCH_label_a705; 
19236                                 
19237                               } /*opt-block*/
19238                               else { 
19239                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
19240                                 goto MATCH_label_a706; 
19241                                 
19242                               } /*opt-block*/
19243                               
19244                               break;
19245                             case 3: 
19246                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
19247                               goto MATCH_label_a703; 
19248                               
19249                               break;
19250                             default: assert(0);
19251                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
19252                         break;
19253                       case 6: 
19254                         
19255                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
19256                             case 0: 
19257                               
19258                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
19259                                   case 0: case 1: case 2: case 3: case 6: 
19260                                   case 7: 
19261                                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
19262                                     goto MATCH_label_a707; 
19263                                     
19264                                     break;
19265                                   case 4: 
19266                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
19267                                     if ((MATCH_w_8_16 & 0x7) 
19268                                             /* base at 16 */ == 5 && 
19269                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19270                                             /* index at 16 */ && 
19271                                       (MATCH_w_8_16 >> 3 & 0x7) 
19272                                             /* index at 16 */ < 8)) { 
19273                                       MATCH_w_32_56 = getDword(7 + MATCH_p); 
19274                                       goto MATCH_label_a709; 
19275                                       
19276                                     } /*opt-block*/
19277                                     else { 
19278                                       MATCH_w_32_24 = getDword(3 + MATCH_p); 
19279                                       goto MATCH_label_a708; 
19280                                       
19281                                     } /*opt-block*/
19282                                     
19283                                     break;
19284                                   case 5: 
19285                                     MATCH_w_32_48 = getDword(6 + MATCH_p); 
19286                                     goto MATCH_label_a710; 
19287                                     
19288                                     break;
19289                                   default: assert(0);
19290                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
19291                               break;
19292                             case 1: 
19293                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19294                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
19295                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19296                                       /* index at 16 */ && 
19297                                 (MATCH_w_8_16 >> 3 & 0x7) 
19298                                       /* index at 16 */ < 8)) { 
19299                                 MATCH_w_32_32 = getDword(4 + MATCH_p); 
19300                                 { 
19301                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
19302                                   unsigned i32 = 
19303                                     MATCH_w_32_32 /* i32 at 32 */;
19304                                   nextPC = 8 + MATCH_p; 
19305                                   
19306                                   #line 1273 "machine/pentium/disassembler.m"
19307                                   
19308 
19309                                           sprintf (str,  "XORid", DIS_EADDR32, DIS_I32);
19310 
19311                                   
19312 
19313                                   
19314                                   
19315                                   
19316                                 }
19317                                 
19318                               } /*opt-block*/
19319                               else { 
19320                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
19321                                 goto MATCH_label_a708; 
19322                                 
19323                               } /*opt-block*/
19324                               
19325                               break;
19326                             case 2: 
19327                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19328                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
19329                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19330                                       /* index at 16 */ && 
19331                                 (MATCH_w_8_16 >> 3 & 0x7) 
19332                                       /* index at 16 */ < 8)) { 
19333                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
19334                                 goto MATCH_label_a709; 
19335                                 
19336                               } /*opt-block*/
19337                               else { 
19338                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
19339                                 goto MATCH_label_a710; 
19340                                 
19341                               } /*opt-block*/
19342                               
19343                               break;
19344                             case 3: 
19345                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
19346                               goto MATCH_label_a707; 
19347                               
19348                               break;
19349                             default: assert(0);
19350                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
19351                         break;
19352                       case 7: 
19353                         
19354                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
19355                             case 0: 
19356                               
19357                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
19358                                   case 0: case 1: case 2: case 3: case 6: 
19359                                   case 7: 
19360                                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
19361                                     goto MATCH_label_a711; 
19362                                     
19363                                     break;
19364                                   case 4: 
19365                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
19366                                     if ((MATCH_w_8_16 & 0x7) 
19367                                             /* base at 16 */ == 5 && 
19368                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19369                                             /* index at 16 */ && 
19370                                       (MATCH_w_8_16 >> 3 & 0x7) 
19371                                             /* index at 16 */ < 8)) { 
19372                                       MATCH_w_32_56 = getDword(7 + MATCH_p); 
19373                                       goto MATCH_label_a713; 
19374                                       
19375                                     } /*opt-block*/
19376                                     else { 
19377                                       MATCH_w_32_24 = getDword(3 + MATCH_p); 
19378                                       goto MATCH_label_a712; 
19379                                       
19380                                     } /*opt-block*/
19381                                     
19382                                     break;
19383                                   case 5: 
19384                                     MATCH_w_32_48 = getDword(6 + MATCH_p); 
19385                                     goto MATCH_label_a714; 
19386                                     
19387                                     break;
19388                                   default: assert(0);
19389                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
19390                               break;
19391                             case 1: 
19392                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19393                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
19394                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19395                                       /* index at 16 */ && 
19396                                 (MATCH_w_8_16 >> 3 & 0x7) 
19397                                       /* index at 16 */ < 8)) { 
19398                                 MATCH_w_32_32 = getDword(4 + MATCH_p); 
19399                                 { 
19400                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
19401                                   unsigned i32 = 
19402                                     MATCH_w_32_32 /* i32 at 32 */;
19403                                   nextPC = 8 + MATCH_p; 
19404                                   
19405                                   #line 1270 "machine/pentium/disassembler.m"
19406                                   
19407 
19408                                           sprintf (str,  "CMPid", DIS_EADDR32, DIS_I32);
19409 
19410                                   
19411 
19412                                   
19413                                   
19414                                   
19415                                 }
19416                                 
19417                               } /*opt-block*/
19418                               else { 
19419                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
19420                                 goto MATCH_label_a712; 
19421                                 
19422                               } /*opt-block*/
19423                               
19424                               break;
19425                             case 2: 
19426                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19427                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
19428                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19429                                       /* index at 16 */ && 
19430                                 (MATCH_w_8_16 >> 3 & 0x7) 
19431                                       /* index at 16 */ < 8)) { 
19432                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
19433                                 goto MATCH_label_a713; 
19434                                 
19435                               } /*opt-block*/
19436                               else { 
19437                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
19438                                 goto MATCH_label_a714; 
19439                                 
19440                               } /*opt-block*/
19441                               
19442                               break;
19443                             case 3: 
19444                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
19445                               goto MATCH_label_a711; 
19446                               
19447                               break;
19448                             default: assert(0);
19449                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
19450                         break;
19451                       default: assert(0);
19452                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
19453                   
19454                   break;
19455                 case 2: 
19456                   goto MATCH_label_a39; break;
19457                 case 3: 
19458                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
19459                   
19460                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
19461                       case 0: 
19462                         
19463                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
19464                             case 0: 
19465                               
19466                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
19467                                   case 0: case 1: case 2: case 3: case 6: 
19468                                   case 7: 
19469                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
19470                                     goto MATCH_label_a715; 
19471                                     
19472                                     break;
19473                                   case 4: 
19474                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
19475                                     if ((MATCH_w_8_16 & 0x7) 
19476                                             /* base at 16 */ == 5 && 
19477                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19478                                             /* index at 16 */ && 
19479                                       (MATCH_w_8_16 >> 3 & 0x7) 
19480                                             /* index at 16 */ < 8)) { 
19481                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
19482                                       goto MATCH_label_a717; 
19483                                       
19484                                     } /*opt-block*/
19485                                     else { 
19486                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
19487                                       goto MATCH_label_a716; 
19488                                       
19489                                     } /*opt-block*/
19490                                     
19491                                     break;
19492                                   case 5: 
19493                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
19494                                     goto MATCH_label_a718; 
19495                                     
19496                                     break;
19497                                   default: assert(0);
19498                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
19499                               break;
19500                             case 1: 
19501                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19502                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
19503                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19504                                       /* index at 16 */ && 
19505                                 (MATCH_w_8_16 >> 3 & 0x7) 
19506                                       /* index at 16 */ < 8)) { 
19507                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
19508                                 { 
19509                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
19510                                   int /* [~128..127] */ i8 = 
19511                                     sign_extend(
19512                                                 (MATCH_w_8_32 & 0xff) 
19513                                                       /* i8 at 32 */, 8);
19514                                   nextPC = 5 + MATCH_p; 
19515                                   
19516                                   #line 1264 "machine/pentium/disassembler.m"
19517                                   
19518 
19519                                           sprintf (str,  "ADDiodb", DIS_EADDR32, DIS_I8);
19520 
19521                                   
19522 
19523                                   
19524                                   
19525                                   
19526                                 }
19527                                 
19528                               } /*opt-block*/
19529                               else { 
19530                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
19531                                 goto MATCH_label_a716; 
19532                                 
19533                               } /*opt-block*/
19534                               
19535                               break;
19536                             case 2: 
19537                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19538                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
19539                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19540                                       /* index at 16 */ && 
19541                                 (MATCH_w_8_16 >> 3 & 0x7) 
19542                                       /* index at 16 */ < 8)) { 
19543                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
19544                                 goto MATCH_label_a717; 
19545                                 
19546                               } /*opt-block*/
19547                               else { 
19548                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
19549                                 goto MATCH_label_a718; 
19550                                 
19551                               } /*opt-block*/
19552                               
19553                               break;
19554                             case 3: 
19555                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19556                               goto MATCH_label_a715; 
19557                               
19558                               break;
19559                             default: assert(0);
19560                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
19561                         break;
19562                       case 1: 
19563                         
19564                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
19565                             case 0: 
19566                               
19567                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
19568                                   case 0: case 1: case 2: case 3: case 6: 
19569                                   case 7: 
19570                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
19571                                     goto MATCH_label_a719; 
19572                                     
19573                                     break;
19574                                   case 4: 
19575                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
19576                                     if ((MATCH_w_8_16 & 0x7) 
19577                                             /* base at 16 */ == 5 && 
19578                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19579                                             /* index at 16 */ && 
19580                                       (MATCH_w_8_16 >> 3 & 0x7) 
19581                                             /* index at 16 */ < 8)) { 
19582                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
19583                                       goto MATCH_label_a721; 
19584                                       
19585                                     } /*opt-block*/
19586                                     else { 
19587                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
19588                                       goto MATCH_label_a720; 
19589                                       
19590                                     } /*opt-block*/
19591                                     
19592                                     break;
19593                                   case 5: 
19594                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
19595                                     goto MATCH_label_a722; 
19596                                     
19597                                     break;
19598                                   default: assert(0);
19599                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
19600                               break;
19601                             case 1: 
19602                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19603                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
19604                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19605                                       /* index at 16 */ && 
19606                                 (MATCH_w_8_16 >> 3 & 0x7) 
19607                                       /* index at 16 */ < 8)) { 
19608                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
19609                                 { 
19610                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
19611                                   int /* [~128..127] */ i8 = 
19612                                     sign_extend(
19613                                                 (MATCH_w_8_32 & 0xff) 
19614                                                       /* i8 at 32 */, 8);
19615                                   nextPC = 5 + MATCH_p; 
19616                                   
19617                                   #line 1258 "machine/pentium/disassembler.m"
19618                                   
19619 
19620                                           sprintf (str,  "ORiodb", DIS_EADDR8, DIS_I8);
19621 
19622                                   
19623 
19624                                   
19625                                   
19626                                   
19627                                 }
19628                                 
19629                               } /*opt-block*/
19630                               else { 
19631                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
19632                                 goto MATCH_label_a720; 
19633                                 
19634                               } /*opt-block*/
19635                               
19636                               break;
19637                             case 2: 
19638                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19639                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
19640                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19641                                       /* index at 16 */ && 
19642                                 (MATCH_w_8_16 >> 3 & 0x7) 
19643                                       /* index at 16 */ < 8)) { 
19644                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
19645                                 goto MATCH_label_a721; 
19646                                 
19647                               } /*opt-block*/
19648                               else { 
19649                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
19650                                 goto MATCH_label_a722; 
19651                                 
19652                               } /*opt-block*/
19653                               
19654                               break;
19655                             case 3: 
19656                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19657                               goto MATCH_label_a719; 
19658                               
19659                               break;
19660                             default: assert(0);
19661                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
19662                         break;
19663                       case 2: 
19664                         
19665                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
19666                             case 0: 
19667                               
19668                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
19669                                   case 0: case 1: case 2: case 3: case 6: 
19670                                   case 7: 
19671                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
19672                                     goto MATCH_label_a723; 
19673                                     
19674                                     break;
19675                                   case 4: 
19676                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
19677                                     if ((MATCH_w_8_16 & 0x7) 
19678                                             /* base at 16 */ == 5 && 
19679                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19680                                             /* index at 16 */ && 
19681                                       (MATCH_w_8_16 >> 3 & 0x7) 
19682                                             /* index at 16 */ < 8)) { 
19683                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
19684                                       goto MATCH_label_a725; 
19685                                       
19686                                     } /*opt-block*/
19687                                     else { 
19688                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
19689                                       goto MATCH_label_a724; 
19690                                       
19691                                     } /*opt-block*/
19692                                     
19693                                     break;
19694                                   case 5: 
19695                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
19696                                     goto MATCH_label_a726; 
19697                                     
19698                                     break;
19699                                   default: assert(0);
19700                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
19701                               break;
19702                             case 1: 
19703                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19704                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
19705                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19706                                       /* index at 16 */ && 
19707                                 (MATCH_w_8_16 >> 3 & 0x7) 
19708                                       /* index at 16 */ < 8)) { 
19709                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
19710                                 { 
19711                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
19712                                   int /* [~128..127] */ i8 = 
19713                                     sign_extend(
19714                                                 (MATCH_w_8_32 & 0xff) 
19715                                                       /* i8 at 32 */, 8);
19716                                   nextPC = 5 + MATCH_p; 
19717                                   
19718                                   #line 1252 "machine/pentium/disassembler.m"
19719                                   
19720 
19721                                           sprintf (str,  "ADCiodb", DIS_EADDR8, DIS_I8);
19722 
19723                                   
19724 
19725                                   
19726                                   
19727                                   
19728                                 }
19729                                 
19730                               } /*opt-block*/
19731                               else { 
19732                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
19733                                 goto MATCH_label_a724; 
19734                                 
19735                               } /*opt-block*/
19736                               
19737                               break;
19738                             case 2: 
19739                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19740                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
19741                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19742                                       /* index at 16 */ && 
19743                                 (MATCH_w_8_16 >> 3 & 0x7) 
19744                                       /* index at 16 */ < 8)) { 
19745                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
19746                                 goto MATCH_label_a725; 
19747                                 
19748                               } /*opt-block*/
19749                               else { 
19750                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
19751                                 goto MATCH_label_a726; 
19752                                 
19753                               } /*opt-block*/
19754                               
19755                               break;
19756                             case 3: 
19757                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19758                               goto MATCH_label_a723; 
19759                               
19760                               break;
19761                             default: assert(0);
19762                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
19763                         break;
19764                       case 3: 
19765                         
19766                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
19767                             case 0: 
19768                               
19769                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
19770                                   case 0: case 1: case 2: case 3: case 6: 
19771                                   case 7: 
19772                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
19773                                     goto MATCH_label_a727; 
19774                                     
19775                                     break;
19776                                   case 4: 
19777                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
19778                                     if ((MATCH_w_8_16 & 0x7) 
19779                                             /* base at 16 */ == 5 && 
19780                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19781                                             /* index at 16 */ && 
19782                                       (MATCH_w_8_16 >> 3 & 0x7) 
19783                                             /* index at 16 */ < 8)) { 
19784                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
19785                                       goto MATCH_label_a729; 
19786                                       
19787                                     } /*opt-block*/
19788                                     else { 
19789                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
19790                                       goto MATCH_label_a728; 
19791                                       
19792                                     } /*opt-block*/
19793                                     
19794                                     break;
19795                                   case 5: 
19796                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
19797                                     goto MATCH_label_a730; 
19798                                     
19799                                     break;
19800                                   default: assert(0);
19801                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
19802                               break;
19803                             case 1: 
19804                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19805                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
19806                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19807                                       /* index at 16 */ && 
19808                                 (MATCH_w_8_16 >> 3 & 0x7) 
19809                                       /* index at 16 */ < 8)) { 
19810                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
19811                                 { 
19812                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
19813                                   int /* [~128..127] */ i8 = 
19814                                     sign_extend(
19815                                                 (MATCH_w_8_32 & 0xff) 
19816                                                       /* i8 at 32 */, 8);
19817                                   nextPC = 5 + MATCH_p; 
19818                                   
19819                                   #line 1246 "machine/pentium/disassembler.m"
19820                                   
19821 
19822                                           sprintf (str,  "SBBiodb", DIS_EADDR32, DIS_I8);
19823 
19824                                   
19825 
19826                                   
19827                                   
19828                                   
19829                                 }
19830                                 
19831                               } /*opt-block*/
19832                               else { 
19833                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
19834                                 goto MATCH_label_a728; 
19835                                 
19836                               } /*opt-block*/
19837                               
19838                               break;
19839                             case 2: 
19840                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19841                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
19842                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19843                                       /* index at 16 */ && 
19844                                 (MATCH_w_8_16 >> 3 & 0x7) 
19845                                       /* index at 16 */ < 8)) { 
19846                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
19847                                 goto MATCH_label_a729; 
19848                                 
19849                               } /*opt-block*/
19850                               else { 
19851                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
19852                                 goto MATCH_label_a730; 
19853                                 
19854                               } /*opt-block*/
19855                               
19856                               break;
19857                             case 3: 
19858                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19859                               goto MATCH_label_a727; 
19860                               
19861                               break;
19862                             default: assert(0);
19863                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
19864                         break;
19865                       case 4: 
19866                         
19867                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
19868                             case 0: 
19869                               
19870                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
19871                                   case 0: case 1: case 2: case 3: case 6: 
19872                                   case 7: 
19873                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
19874                                     goto MATCH_label_a731; 
19875                                     
19876                                     break;
19877                                   case 4: 
19878                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
19879                                     if ((MATCH_w_8_16 & 0x7) 
19880                                             /* base at 16 */ == 5 && 
19881                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19882                                             /* index at 16 */ && 
19883                                       (MATCH_w_8_16 >> 3 & 0x7) 
19884                                             /* index at 16 */ < 8)) { 
19885                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
19886                                       goto MATCH_label_a733; 
19887                                       
19888                                     } /*opt-block*/
19889                                     else { 
19890                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
19891                                       goto MATCH_label_a732; 
19892                                       
19893                                     } /*opt-block*/
19894                                     
19895                                     break;
19896                                   case 5: 
19897                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
19898                                     goto MATCH_label_a734; 
19899                                     
19900                                     break;
19901                                   default: assert(0);
19902                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
19903                               break;
19904                             case 1: 
19905                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19906                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
19907                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19908                                       /* index at 16 */ && 
19909                                 (MATCH_w_8_16 >> 3 & 0x7) 
19910                                       /* index at 16 */ < 8)) { 
19911                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
19912                                 { 
19913                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
19914                                   int /* [~128..127] */ i8 = 
19915                                     sign_extend(
19916                                                 (MATCH_w_8_32 & 0xff) 
19917                                                       /* i8 at 32 */, 8);
19918                                   nextPC = 5 + MATCH_p; 
19919                                   
19920                                   #line 1240 "machine/pentium/disassembler.m"
19921                                   
19922 
19923                                           sprintf (str,  "ANDiodb", DIS_EADDR8, DIS_I8);
19924 
19925                                   
19926 
19927                                   
19928                                   
19929                                   
19930                                 }
19931                                 
19932                               } /*opt-block*/
19933                               else { 
19934                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
19935                                 goto MATCH_label_a732; 
19936                                 
19937                               } /*opt-block*/
19938                               
19939                               break;
19940                             case 2: 
19941                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19942                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
19943                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19944                                       /* index at 16 */ && 
19945                                 (MATCH_w_8_16 >> 3 & 0x7) 
19946                                       /* index at 16 */ < 8)) { 
19947                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
19948                                 goto MATCH_label_a733; 
19949                                 
19950                               } /*opt-block*/
19951                               else { 
19952                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
19953                                 goto MATCH_label_a734; 
19954                                 
19955                               } /*opt-block*/
19956                               
19957                               break;
19958                             case 3: 
19959                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
19960                               goto MATCH_label_a731; 
19961                               
19962                               break;
19963                             default: assert(0);
19964                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
19965                         break;
19966                       case 5: 
19967                         
19968                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
19969                             case 0: 
19970                               
19971                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
19972                                   case 0: case 1: case 2: case 3: case 6: 
19973                                   case 7: 
19974                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
19975                                     goto MATCH_label_a735; 
19976                                     
19977                                     break;
19978                                   case 4: 
19979                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
19980                                     if ((MATCH_w_8_16 & 0x7) 
19981                                             /* base at 16 */ == 5 && 
19982                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
19983                                             /* index at 16 */ && 
19984                                       (MATCH_w_8_16 >> 3 & 0x7) 
19985                                             /* index at 16 */ < 8)) { 
19986                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
19987                                       goto MATCH_label_a737; 
19988                                       
19989                                     } /*opt-block*/
19990                                     else { 
19991                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
19992                                       goto MATCH_label_a736; 
19993                                       
19994                                     } /*opt-block*/
19995                                     
19996                                     break;
19997                                   case 5: 
19998                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
19999                                     goto MATCH_label_a738; 
20000                                     
20001                                     break;
20002                                   default: assert(0);
20003                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
20004                               break;
20005                             case 1: 
20006                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
20007                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
20008                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20009                                       /* index at 16 */ && 
20010                                 (MATCH_w_8_16 >> 3 & 0x7) 
20011                                       /* index at 16 */ < 8)) { 
20012                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
20013                                 { 
20014                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
20015                                   int /* [~128..127] */ i8 = 
20016                                     sign_extend(
20017                                                 (MATCH_w_8_32 & 0xff) 
20018                                                       /* i8 at 32 */, 8);
20019                                   nextPC = 5 + MATCH_p; 
20020                                   
20021                                   #line 1234 "machine/pentium/disassembler.m"
20022                                   
20023 
20024                                           sprintf (str,  "SUBiodb", DIS_EADDR32, DIS_I8);
20025 
20026                                   
20027 
20028                                   
20029                                   
20030                                   
20031                                 }
20032                                 
20033                               } /*opt-block*/
20034                               else { 
20035                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
20036                                 goto MATCH_label_a736; 
20037                                 
20038                               } /*opt-block*/
20039                               
20040                               break;
20041                             case 2: 
20042                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
20043                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
20044                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20045                                       /* index at 16 */ && 
20046                                 (MATCH_w_8_16 >> 3 & 0x7) 
20047                                       /* index at 16 */ < 8)) { 
20048                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
20049                                 goto MATCH_label_a737; 
20050                                 
20051                               } /*opt-block*/
20052                               else { 
20053                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
20054                                 goto MATCH_label_a738; 
20055                                 
20056                               } /*opt-block*/
20057                               
20058                               break;
20059                             case 3: 
20060                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
20061                               goto MATCH_label_a735; 
20062                               
20063                               break;
20064                             default: assert(0);
20065                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
20066                         break;
20067                       case 6: 
20068                         
20069                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
20070                             case 0: 
20071                               
20072                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
20073                                   case 0: case 1: case 2: case 3: case 6: 
20074                                   case 7: 
20075                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
20076                                     goto MATCH_label_a739; 
20077                                     
20078                                     break;
20079                                   case 4: 
20080                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
20081                                     if ((MATCH_w_8_16 & 0x7) 
20082                                             /* base at 16 */ == 5 && 
20083                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20084                                             /* index at 16 */ && 
20085                                       (MATCH_w_8_16 >> 3 & 0x7) 
20086                                             /* index at 16 */ < 8)) { 
20087                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
20088                                       goto MATCH_label_a741; 
20089                                       
20090                                     } /*opt-block*/
20091                                     else { 
20092                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20093                                       goto MATCH_label_a740; 
20094                                       
20095                                     } /*opt-block*/
20096                                     
20097                                     break;
20098                                   case 5: 
20099                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
20100                                     goto MATCH_label_a742; 
20101                                     
20102                                     break;
20103                                   default: assert(0);
20104                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
20105                               break;
20106                             case 1: 
20107                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
20108                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
20109                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20110                                       /* index at 16 */ && 
20111                                 (MATCH_w_8_16 >> 3 & 0x7) 
20112                                       /* index at 16 */ < 8)) { 
20113                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
20114                                 { 
20115                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
20116                                   int /* [~128..127] */ i8 = 
20117                                     sign_extend(
20118                                                 (MATCH_w_8_32 & 0xff) 
20119                                                       /* i8 at 32 */, 8);
20120                                   nextPC = 5 + MATCH_p; 
20121                                   
20122                                   #line 1228 "machine/pentium/disassembler.m"
20123                                   
20124 
20125                                           sprintf (str,  "XORiodb", DIS_EADDR8, DIS_I8);
20126 
20127                                   
20128 
20129                                   
20130                                   
20131                                   
20132                                 }
20133                                 
20134                               } /*opt-block*/
20135                               else { 
20136                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
20137                                 goto MATCH_label_a740; 
20138                                 
20139                               } /*opt-block*/
20140                               
20141                               break;
20142                             case 2: 
20143                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
20144                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
20145                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20146                                       /* index at 16 */ && 
20147                                 (MATCH_w_8_16 >> 3 & 0x7) 
20148                                       /* index at 16 */ < 8)) { 
20149                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
20150                                 goto MATCH_label_a741; 
20151                                 
20152                               } /*opt-block*/
20153                               else { 
20154                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
20155                                 goto MATCH_label_a742; 
20156                                 
20157                               } /*opt-block*/
20158                               
20159                               break;
20160                             case 3: 
20161                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
20162                               goto MATCH_label_a739; 
20163                               
20164                               break;
20165                             default: assert(0);
20166                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
20167                         break;
20168                       case 7: 
20169                         
20170                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
20171                             case 0: 
20172                               
20173                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
20174                                   case 0: case 1: case 2: case 3: case 6: 
20175                                   case 7: 
20176                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
20177                                     goto MATCH_label_a743; 
20178                                     
20179                                     break;
20180                                   case 4: 
20181                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
20182                                     if ((MATCH_w_8_16 & 0x7) 
20183                                             /* base at 16 */ == 5 && 
20184                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20185                                             /* index at 16 */ && 
20186                                       (MATCH_w_8_16 >> 3 & 0x7) 
20187                                             /* index at 16 */ < 8)) { 
20188                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
20189                                       goto MATCH_label_a745; 
20190                                       
20191                                     } /*opt-block*/
20192                                     else { 
20193                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
20194                                       goto MATCH_label_a744; 
20195                                       
20196                                     } /*opt-block*/
20197                                     
20198                                     break;
20199                                   case 5: 
20200                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
20201                                     goto MATCH_label_a746; 
20202                                     
20203                                     break;
20204                                   default: assert(0);
20205                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
20206                               break;
20207                             case 1: 
20208                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
20209                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
20210                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20211                                       /* index at 16 */ && 
20212                                 (MATCH_w_8_16 >> 3 & 0x7) 
20213                                       /* index at 16 */ < 8)) { 
20214                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
20215                                 { 
20216                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
20217                                   int /* [~128..127] */ i8 = 
20218                                     sign_extend(
20219                                                 (MATCH_w_8_32 & 0xff) 
20220                                                       /* i8 at 32 */, 8);
20221                                   nextPC = 5 + MATCH_p; 
20222                                   
20223                                   #line 1222 "machine/pentium/disassembler.m"
20224                                   
20225 
20226                                           sprintf (str,  "CMPiodb", DIS_EADDR32, DIS_I8);
20227 
20228                                   
20229 
20230                                   
20231                                   
20232                                   
20233                                 }
20234                                 
20235                               } /*opt-block*/
20236                               else { 
20237                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
20238                                 goto MATCH_label_a744; 
20239                                 
20240                               } /*opt-block*/
20241                               
20242                               break;
20243                             case 2: 
20244                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
20245                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
20246                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20247                                       /* index at 16 */ && 
20248                                 (MATCH_w_8_16 >> 3 & 0x7) 
20249                                       /* index at 16 */ < 8)) { 
20250                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
20251                                 goto MATCH_label_a745; 
20252                                 
20253                               } /*opt-block*/
20254                               else { 
20255                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
20256                                 goto MATCH_label_a746; 
20257                                 
20258                               } /*opt-block*/
20259                               
20260                               break;
20261                             case 3: 
20262                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
20263                               goto MATCH_label_a743; 
20264                               
20265                               break;
20266                             default: assert(0);
20267                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
20268                         break;
20269                       default: assert(0);
20270                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
20271                   
20272                   break;
20273                 case 4: 
20274                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
20275                   
20276                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
20277                       case 0: 
20278                         
20279                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
20280                             case 0: case 1: case 2: case 3: case 6: case 7: 
20281                               goto MATCH_label_a747; break;
20282                             case 4: 
20283                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
20284                               if ((MATCH_w_8_16 & 0x7) 
20285                                       /* base at 16 */ == 5 && 
20286                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20287                                       /* index at 16 */ && 
20288                                 (MATCH_w_8_16 >> 3 & 0x7) 
20289                                       /* index at 16 */ < 8)) 
20290                                 goto MATCH_label_a749;  /*opt-block+*/
20291                               else 
20292                                 goto MATCH_label_a748;  /*opt-block+*/
20293                               
20294                               break;
20295                             case 5: 
20296                               goto MATCH_label_a750; break;
20297                             default: assert(0);
20298                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
20299                         break;
20300                       case 1: 
20301                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
20302                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
20303                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20304                                 /* index at 16 */ && 
20305                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
20306                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
20307                           unsigned reg = 
20308                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
20309                           nextPC = 4 + MATCH_p; 
20310                           
20311                           #line 101 "machine/pentium/disassembler.m"
20312                           
20313 
20314                                   sprintf (str,  "TEST.Eb.Gb", DIS_EADDR8, DIS_REG8);
20315 
20316                           
20317 
20318                           
20319                           
20320                           
20321                         } /*opt-block*//*opt-block+*/
20322                         else 
20323                           goto MATCH_label_a748;  /*opt-block+*/
20324                         
20325                         break;
20326                       case 2: 
20327                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
20328                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
20329                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20330                                 /* index at 16 */ && 
20331                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
20332                           goto MATCH_label_a749;  /*opt-block+*/
20333                         else 
20334                           goto MATCH_label_a750;  /*opt-block+*/
20335                         
20336                         break;
20337                       case 3: 
20338                         goto MATCH_label_a747; break;
20339                       default: assert(0);
20340                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
20341                   
20342                   break;
20343                 case 5: 
20344                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
20345                   
20346                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
20347                       case 0: 
20348                         
20349                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
20350                             case 0: case 1: case 2: case 3: case 6: case 7: 
20351                               goto MATCH_label_a751; break;
20352                             case 4: 
20353                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
20354                               if ((MATCH_w_8_16 & 0x7) 
20355                                       /* base at 16 */ == 5 && 
20356                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20357                                       /* index at 16 */ && 
20358                                 (MATCH_w_8_16 >> 3 & 0x7) 
20359                                       /* index at 16 */ < 8)) 
20360                                 goto MATCH_label_a753;  /*opt-block+*/
20361                               else 
20362                                 goto MATCH_label_a752;  /*opt-block+*/
20363                               
20364                               break;
20365                             case 5: 
20366                               goto MATCH_label_a754; break;
20367                             default: assert(0);
20368                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
20369                         break;
20370                       case 1: 
20371                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
20372                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
20373                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20374                                 /* index at 16 */ && 
20375                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
20376                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
20377                           unsigned reg = 
20378                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
20379                           nextPC = 4 + MATCH_p; 
20380                           
20381                           #line 95 "machine/pentium/disassembler.m"
20382                           
20383 
20384                                   sprintf (str,  "TEST.Ev.Gvod", DIS_EADDR32, DIS_REG32);
20385 
20386                           
20387 
20388                           
20389                           
20390                           
20391                         } /*opt-block*//*opt-block+*/
20392                         else 
20393                           goto MATCH_label_a752;  /*opt-block+*/
20394                         
20395                         break;
20396                       case 2: 
20397                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
20398                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
20399                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20400                                 /* index at 16 */ && 
20401                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
20402                           goto MATCH_label_a753;  /*opt-block+*/
20403                         else 
20404                           goto MATCH_label_a754;  /*opt-block+*/
20405                         
20406                         break;
20407                       case 3: 
20408                         goto MATCH_label_a751; break;
20409                       default: assert(0);
20410                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
20411                   
20412                   break;
20413                 case 6: 
20414                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
20415                   
20416                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
20417                       case 0: 
20418                         
20419                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
20420                             case 0: case 1: case 2: case 3: case 6: case 7: 
20421                               goto MATCH_label_a755; break;
20422                             case 4: 
20423                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
20424                               if ((MATCH_w_8_16 & 0x7) 
20425                                       /* base at 16 */ == 5 && 
20426                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20427                                       /* index at 16 */ && 
20428                                 (MATCH_w_8_16 >> 3 & 0x7) 
20429                                       /* index at 16 */ < 8)) 
20430                                 goto MATCH_label_a757;  /*opt-block+*/
20431                               else 
20432                                 goto MATCH_label_a756;  /*opt-block+*/
20433                               
20434                               break;
20435                             case 5: 
20436                               goto MATCH_label_a758; break;
20437                             default: assert(0);
20438                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
20439                         break;
20440                       case 1: 
20441                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
20442                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
20443                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20444                                 /* index at 16 */ && 
20445                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
20446                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
20447                           unsigned reg = 
20448                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
20449                           nextPC = 4 + MATCH_p; 
20450                           
20451                           #line 53 "machine/pentium/disassembler.m"
20452                           
20453 
20454                                   sprintf (str, "%s %s,%s", "XCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
20455 
20456                           
20457 
20458                           
20459                           
20460                           
20461                         } /*opt-block*//*opt-block+*/
20462                         else 
20463                           goto MATCH_label_a756;  /*opt-block+*/
20464                         
20465                         break;
20466                       case 2: 
20467                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
20468                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
20469                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20470                                 /* index at 16 */ && 
20471                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
20472                           goto MATCH_label_a757;  /*opt-block+*/
20473                         else 
20474                           goto MATCH_label_a758;  /*opt-block+*/
20475                         
20476                         break;
20477                       case 3: 
20478                         goto MATCH_label_a755; break;
20479                       default: assert(0);
20480                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
20481                   
20482                   break;
20483                 case 7: 
20484                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
20485                   
20486                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
20487                       case 0: 
20488                         
20489                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
20490                             case 0: case 1: case 2: case 3: case 6: case 7: 
20491                               goto MATCH_label_a759; break;
20492                             case 4: 
20493                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
20494                               if ((MATCH_w_8_16 & 0x7) 
20495                                       /* base at 16 */ == 5 && 
20496                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20497                                       /* index at 16 */ && 
20498                                 (MATCH_w_8_16 >> 3 & 0x7) 
20499                                       /* index at 16 */ < 8)) 
20500                                 goto MATCH_label_a761;  /*opt-block+*/
20501                               else 
20502                                 goto MATCH_label_a760;  /*opt-block+*/
20503                               
20504                               break;
20505                             case 5: 
20506                               goto MATCH_label_a762; break;
20507                             default: assert(0);
20508                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
20509                         break;
20510                       case 1: 
20511                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
20512                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
20513                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20514                                 /* index at 16 */ && 
20515                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
20516                           unsigned Eaddr = 1 + addressToPC(MATCH_p);
20517                           unsigned reg = 
20518                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
20519                           nextPC = 4 + MATCH_p; 
20520                           
20521                           #line 47 "machine/pentium/disassembler.m"
20522                           
20523 
20524                                   sprintf (str, "%s %s,%s", "XCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
20525 
20526                           
20527 
20528                           
20529                           
20530                           
20531                         } /*opt-block*//*opt-block+*/
20532                         else 
20533                           goto MATCH_label_a760;  /*opt-block+*/
20534                         
20535                         break;
20536                       case 2: 
20537                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
20538                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
20539                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
20540                                 /* index at 16 */ && 
20541                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
20542                           goto MATCH_label_a761;  /*opt-block+*/
20543                         else 
20544                           goto MATCH_label_a762;  /*opt-block+*/
20545                         
20546                         break;
20547                       case 3: 
20548                         goto MATCH_label_a759; break;
20549                       default: assert(0);
20550                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
20551                   
20552                   break;
20553                 default: assert(0);
20554               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/  
20555           break;
20556         case 9: 
20557           if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) 
20558             
20559               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
20560                 case 0: 
20561                   nextPC = 1 + MATCH_p; 
20562                   
20563                   #line 974 "machine/pentium/disassembler.m"
20564                   
20565 
20566                           sprintf (str,  "CWDE");
20567 
20568                   
20569 
20570                   
20571                   
20572                   
20573                   
20574                   break;
20575                 case 1: 
20576                   nextPC = 1 + MATCH_p; 
20577                   
20578                   #line 929 "machine/pentium/disassembler.m"
20579                   
20580 
20581                           sprintf (str,  "CDQ");
20582 
20583                   
20584 
20585                   
20586                   
20587                   
20588                   
20589                   break;
20590                 case 2: 
20591                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
20592                   MATCH_w_16_40 = getWord(5 + MATCH_p); 
20593                   { 
20594                     unsigned off = MATCH_w_32_8 /* i32 at 8 */;
20595                     unsigned seg = (MATCH_w_16_40 & 0xffff) /* i16 at 40 */;
20596                     nextPC = 7 + MATCH_p; 
20597                     
20598                     #line 982 "machine/pentium/disassembler.m"
20599                     
20600 
20601                             unused(seg); unused(off);
20602 
20603                             sprintf (str, "NOP");
20604 
20605                     
20606 
20607                     
20608                     
20609                     
20610                   }
20611                   
20612                   break;
20613                 case 3: 
20614                   nextPC = 1 + MATCH_p; 
20615                   
20616                   #line 86 "machine/pentium/disassembler.m"
20617                   
20618 
20619                           sprintf (str,  "WAIT");
20620 
20621                   
20622 
20623                   
20624                   
20625                   
20626                   
20627                   break;
20628                 case 4: 
20629                   nextPC = 1 + MATCH_p; 
20630                   
20631                   #line 495 "machine/pentium/disassembler.m"
20632                   
20633 
20634                           sprintf (str,  "PUSHFod");
20635 
20636                   
20637 
20638                   
20639                   
20640                   
20641                   
20642                   break;
20643                 case 5: 
20644                   nextPC = 1 + MATCH_p; 
20645                   
20646                   #line 549 "machine/pentium/disassembler.m"
20647                   
20648 
20649                           sprintf (str,  "POPFod");
20650 
20651                   
20652 
20653                   
20654                   
20655                   
20656                   
20657                   break;
20658                 case 6: 
20659                   nextPC = 1 + MATCH_p; 
20660                   
20661                   #line 189 "machine/pentium/disassembler.m"
20662                   
20663 
20664                           sprintf (str,  "SAHF");
20665 
20666                   
20667 
20668                   
20669                   
20670                   
20671                   
20672                   break;
20673                 case 7: 
20674                   nextPC = 1 + MATCH_p; 
20675                   
20676                   #line 793 "machine/pentium/disassembler.m"
20677                   
20678 
20679                           sprintf (str,  "LAHF");
20680 
20681                   
20682 
20683                       /* Branches have been handled in decodeInstruction() now */
20684 
20685                   
20686                   
20687                   
20688                   
20689                   break;
20690                 default: assert(0);
20691               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/  
20692           else 
20693             if ((MATCH_w_8_0 & 0x7) /* col at 0 */ == 0) { 
20694               nextPC = 1 + MATCH_p; 
20695               
20696               #line 56 "machine/pentium/disassembler.m"
20697               
20698 
20699                       sprintf (str, "%s", "NOP");
20700 
20701               
20702 
20703               
20704               
20705               
20706             } /*opt-block*//*opt-block+*/
20707             else { 
20708               unsigned r32 = (MATCH_w_8_0 & 0x7) /* r32 at 0 */;
20709               nextPC = 1 + MATCH_p; 
20710               
20711               #line 65 "machine/pentium/disassembler.m"
20712               
20713 
20714                       sprintf (str,  "XCHGeAXod", DIS_R32);
20715 
20716               
20717 
20718               
20719               
20720               
20721             } /*opt-block*//*opt-block+*/ /*opt-block+*/
20722           break;
20723         case 10: 
20724           if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) 
20725             
20726               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
20727                 case 0: 
20728                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
20729                   { 
20730                     unsigned i8 = (MATCH_w_8_8 & 0xff) /* i8 at 8 */;
20731                     nextPC = 2 + MATCH_p; 
20732                     
20733                     #line 119 "machine/pentium/disassembler.m"
20734                     
20735 
20736                             sprintf (str,  "TEST.AL.Ib", DIS_I8);
20737 
20738                     
20739 
20740                     
20741                     
20742                     
20743                   }
20744                   
20745                   break;
20746                 case 1: 
20747                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
20748                   { 
20749                     unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
20750                     nextPC = 5 + MATCH_p; 
20751                     
20752                     #line 113 "machine/pentium/disassembler.m"
20753                     
20754 
20755                             sprintf (str,  "TEST.eAX.Ivod", DIS_I32);
20756 
20757                     
20758 
20759                     
20760                     
20761                     
20762                   }
20763                   
20764                   break;
20765                 case 2: 
20766                   nextPC = 1 + MATCH_p; 
20767                   
20768                   #line 131 "machine/pentium/disassembler.m"
20769                   
20770 
20771                           sprintf (str,  "STOSB");
20772 
20773                   
20774 
20775                   
20776                   
20777                   
20778                   
20779                   break;
20780                 case 3: 
20781                   nextPC = 1 + MATCH_p; 
20782                   
20783                   #line 125 "machine/pentium/disassembler.m"
20784                   
20785 
20786                           sprintf (str,  "STOSvod");
20787 
20788                   
20789 
20790                   
20791                   
20792                   
20793                   
20794                   break;
20795                 case 4: 
20796                   nextPC = 1 + MATCH_p; 
20797                   
20798                   #line 1420 "machine/pentium/disassembler.m"
20799                   
20800 
20801                           sprintf (str,  "LODSB");
20802 
20803                   
20804 
20805                       /* Floating point instructions */
20806 
20807                   
20808                   
20809                   
20810                   
20811                   break;
20812                 case 5: 
20813                   nextPC = 1 + MATCH_p; 
20814                   
20815                   #line 1414 "machine/pentium/disassembler.m"
20816                   
20817 
20818                           sprintf (str,  "LODSvod");
20819 
20820                   
20821 
20822                   
20823                   
20824                   
20825                   
20826                   break;
20827                 case 6: 
20828                   nextPC = 1 + MATCH_p; 
20829                   
20830                   #line 186 "machine/pentium/disassembler.m"
20831                   
20832 
20833                           sprintf (str,  "SCASB");
20834 
20835                   
20836 
20837                   
20838                   
20839                   
20840                   
20841                   break;
20842                 case 7: 
20843                   nextPC = 1 + MATCH_p; 
20844                   
20845                   #line 180 "machine/pentium/disassembler.m"
20846                   
20847 
20848                           sprintf (str,  "SCASvod");
20849 
20850                   
20851 
20852                   
20853                   
20854                   
20855                   
20856                   break;
20857                 default: assert(0);
20858               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/  
20859           else 
20860             
20861               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
20862                 case 0: 
20863                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
20864                   { 
20865                     unsigned off = MATCH_w_32_8 /* i32 at 8 */;
20866                     nextPC = 5 + MATCH_p; 
20867                     
20868                     #line 718 "machine/pentium/disassembler.m"
20869                     
20870 
20871                             sprintf (str,  "MOV.AL.Ob", DIS_OFF);
20872 
20873                     
20874 
20875                     //    | MOV.Sw.Ew(Mem, sr16) =>
20876 
20877                     //        sprintf (str,  "MOV.Sw.Ew", DIS_MEM, DIS_SR16);
20878 
20879                     
20880 
20881                     //    | MOV.Ew.Sw(Mem, sr16) =>
20882 
20883                     //        sprintf (str,  "MOV.Ew.Sw", DIS_MEM, DIS_SR16);
20884 
20885                     
20886 
20887                     
20888                     
20889                     
20890                   }
20891                   
20892                   break;
20893                 case 1: 
20894                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
20895                   { 
20896                     unsigned off = MATCH_w_32_8 /* i32 at 8 */;
20897                     nextPC = 5 + MATCH_p; 
20898                     
20899                     #line 712 "machine/pentium/disassembler.m"
20900                     
20901 
20902                             sprintf (str,  "MOV.eAX.Ovod", DIS_OFF);
20903 
20904                     
20905 
20906                     
20907                     
20908                     
20909                   }
20910                   
20911                   break;
20912                 case 2: 
20913                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
20914                   { 
20915                     unsigned off = MATCH_w_32_8 /* i32 at 8 */;
20916                     nextPC = 5 + MATCH_p; 
20917                     
20918                     #line 709 "machine/pentium/disassembler.m"
20919                     
20920 
20921                             sprintf (str,  "MOV.Ob.AL", DIS_OFF);
20922 
20923                     
20924 
20925                     
20926                     
20927                     
20928                   }
20929                   
20930                   break;
20931                 case 3: 
20932                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
20933                   { 
20934                     unsigned off = MATCH_w_32_8 /* i32 at 8 */;
20935                     nextPC = 5 + MATCH_p; 
20936                     
20937                     #line 703 "machine/pentium/disassembler.m"
20938                     
20939 
20940                             sprintf (str,  "MOV.Ov.eAXod", DIS_OFF);
20941 
20942                     
20943 
20944                     
20945                     
20946                     
20947                   }
20948                   
20949                   break;
20950                 case 4: 
20951                   nextPC = 1 + MATCH_p; 
20952                   
20953                   #line 666 "machine/pentium/disassembler.m"
20954                   
20955 
20956                           sprintf (str,  "MOVSB");
20957 
20958                   
20959 
20960                   //    | MOV.Rd.Dd(reg, dr) => 
20961 
20962                   //        unused(reg); unused(dr);
20963 
20964                   //        sprintf (str,  "UNIMP");
20965 
20966                   
20967 
20968                   //    | MOV.Dd.Rd(dr, reg) =>
20969 
20970                   //        unused(reg); unused(dr);
20971 
20972                   //        sprintf (str,  "UNIMP");
20973 
20974                   
20975 
20976                   //    | MOV.Rd.Cd(reg, cr) =>
20977 
20978                   //        unused(reg); unused(cr);
20979 
20980                   //        sprintf (str,  "UNIMP");
20981 
20982                   
20983 
20984                   //    | MOV.Cd.Rd(cr, reg) =>
20985 
20986                   //        unused(reg); unused(cr);
20987 
20988                   //        sprintf (str,  "UNIMP");
20989 
20990                   
20991 
20992                   
20993                   
20994                   
20995                   
20996                   break;
20997                 case 5: 
20998                   nextPC = 1 + MATCH_p; 
20999                   
21000                   #line 660 "machine/pentium/disassembler.m"
21001                   
21002 
21003                           sprintf (str,  "MOVSvod");
21004 
21005                   
21006 
21007                   
21008                   
21009                   
21010                   
21011                   break;
21012                 case 6: 
21013                   nextPC = 1 + MATCH_p; 
21014                   
21015                   #line 956 "machine/pentium/disassembler.m"
21016                   
21017 
21018                           sprintf (str,  "CMPSB");
21019 
21020                   
21021 
21022                   
21023                   
21024                   
21025                   
21026                   break;
21027                 case 7: 
21028                   nextPC = 1 + MATCH_p; 
21029                   
21030                   #line 950 "machine/pentium/disassembler.m"
21031                   
21032 
21033                           sprintf (str,  "CMPSvod");
21034 
21035                   
21036 
21037                   
21038                   
21039                   
21040                   
21041                   break;
21042                 default: assert(0);
21043               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/  
21044           break;
21045         case 11: 
21046           if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
21047             MATCH_w_32_8 = getDword(1 + MATCH_p); 
21048             { 
21049               unsigned i32 = MATCH_w_32_8 /* i32 at 8 */;
21050               unsigned r32 = (MATCH_w_8_0 & 0x7) /* r32 at 0 */;
21051               nextPC = 5 + MATCH_p; 
21052               
21053               #line 694 "machine/pentium/disassembler.m"
21054               
21055 
21056                       sprintf (str,  "MOVid", DIS_R32, DIS_I32);
21057 
21058               
21059 
21060               
21061               
21062               
21063             }
21064             
21065           } /*opt-block*/
21066           else { 
21067             MATCH_w_8_8 = getByte(1 + MATCH_p); 
21068             { 
21069               int /* [~128..127] */ i8 = 
21070                 sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
21071               unsigned r8 = (MATCH_w_8_0 & 0x7) /* r8 at 0 */;
21072               nextPC = 2 + MATCH_p; 
21073               
21074               #line 700 "machine/pentium/disassembler.m"
21075               
21076 
21077                       sprintf (str,  "MOVib", DIS_R8, DIS_I8);
21078 
21079               
21080 
21081               
21082               
21083               
21084             }
21085             
21086           } /*opt-block*/
21087           
21088           break;
21089         case 12: 
21090           if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) 
21091             
21092               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
21093                 case 0: 
21094                   MATCH_w_16_8 = getWord(1 + MATCH_p); 
21095                   MATCH_w_8_24 = getByte(3 + MATCH_p); 
21096                   { 
21097                     unsigned i16 = (MATCH_w_16_8 & 0xffff) /* i16 at 8 */;
21098                     int /* [~128..127] */ i8 = 
21099                       sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
21100                     nextPC = 4 + MATCH_p; 
21101                     
21102                     #line 896 "machine/pentium/disassembler.m"
21103                     
21104 
21105                             sprintf (str,  "ENTER", DIS_I16, DIS_I8);
21106 
21107                     
21108 
21109                     
21110                     
21111                     
21112                   }
21113                   
21114                   break;
21115                 case 1: 
21116                   nextPC = 1 + MATCH_p; 
21117                   
21118                   #line 775 "machine/pentium/disassembler.m"
21119                   
21120 
21121                           sprintf (str,  "LEAVE");
21122 
21123                   
21124 
21125                   
21126                   
21127                   
21128                   
21129                   break;
21130                 case 2: 
21131                   MATCH_w_16_8 = getWord(1 + MATCH_p); 
21132                   { 
21133                     unsigned i16 = (MATCH_w_16_8 & 0xffff) /* i16 at 8 */;
21134                     nextPC = 3 + MATCH_p; 
21135                     
21136                     #line 195 "machine/pentium/disassembler.m"
21137                     
21138 
21139                             sprintf (str,  "RET.far.Iw", DIS_I16);
21140 
21141                     
21142 
21143                     
21144                     
21145                     
21146                   }
21147                   
21148                   break;
21149                 case 3: 
21150                   nextPC = 1 + MATCH_p; 
21151                   
21152                   #line 201 "machine/pentium/disassembler.m"
21153                   
21154 
21155                           sprintf (str,  "RET.far");
21156 
21157                   
21158 
21159                   
21160                   
21161                   
21162                   
21163                   break;
21164                 case 4: 
21165                   nextPC = 1 + MATCH_p; 
21166                   
21167                   #line 812 "machine/pentium/disassembler.m"
21168                   
21169 
21170                           sprintf (str,  "INT3");
21171 
21172                   
21173 
21174                   //    | INSvod() =>
21175 
21176                   //        sprintf (str,  "INSvod");
21177 
21178                   
21179 
21180                   //    | INSvow() =>
21181 
21182                   //        sprintf (str,  "INSvow");
21183 
21184                   
21185 
21186                   //    | INSB() =>
21187 
21188                   //        sprintf (str,  "INSB");
21189 
21190                   
21191 
21192                   
21193                   
21194                   
21195                   
21196                   break;
21197                 case 5: 
21198                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
21199                   { 
21200                     int /* [~128..127] */ i8 = 
21201                       sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 8);
21202                     nextPC = 2 + MATCH_p; 
21203                     
21204                     #line 809 "machine/pentium/disassembler.m"
21205                     
21206 
21207                             sprintf (str,  "INT.Ib", DIS_I8);
21208 
21209                     
21210 
21211                     
21212                     
21213                     
21214                   }
21215                   
21216                   break;
21217                 case 6: 
21218                   nextPC = 1 + MATCH_p; 
21219                   
21220                   #line 806 "machine/pentium/disassembler.m"
21221                   
21222 
21223                           sprintf (str,  "INTO");
21224 
21225                   
21226 
21227                   
21228                   
21229                   
21230                   
21231                   break;
21232                 case 7: 
21233                   nextPC = 1 + MATCH_p; 
21234                   
21235                   #line 797 "machine/pentium/disassembler.m"
21236                   
21237 
21238                           sprintf (str,  "IRET");
21239 
21240                   
21241 
21242                   
21243                   
21244                   
21245                   
21246                   break;
21247                 default: assert(0);
21248               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/  
21249           else 
21250             
21251               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
21252                 case 0: 
21253                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
21254                   
21255                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
21256                       case 0: 
21257                         
21258                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
21259                             case 0: 
21260                               
21261                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
21262                                   case 0: case 1: case 2: case 3: case 6: 
21263                                   case 7: 
21264                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
21265                                     goto MATCH_label_a785; 
21266                                     
21267                                     break;
21268                                   case 4: 
21269                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
21270                                     if ((MATCH_w_8_16 & 0x7) 
21271                                             /* base at 16 */ == 5 && 
21272                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21273                                             /* index at 16 */ && 
21274                                       (MATCH_w_8_16 >> 3 & 0x7) 
21275                                             /* index at 16 */ < 8)) { 
21276                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
21277                                       goto MATCH_label_a787; 
21278                                       
21279                                     } /*opt-block*/
21280                                     else { 
21281                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
21282                                       goto MATCH_label_a786; 
21283                                       
21284                                     } /*opt-block*/
21285                                     
21286                                     break;
21287                                   case 5: 
21288                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
21289                                     goto MATCH_label_a788; 
21290                                     
21291                                     break;
21292                                   default: assert(0);
21293                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
21294                               break;
21295                             case 1: 
21296                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21297                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
21298                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21299                                       /* index at 16 */ && 
21300                                 (MATCH_w_8_16 >> 3 & 0x7) 
21301                                       /* index at 16 */ < 8)) { 
21302                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
21303                                 { 
21304                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
21305                                   int /* [~128..127] */ i8 = 
21306                                     sign_extend(
21307                                                 (MATCH_w_8_32 & 0xff) 
21308                                                       /* i8 at 32 */, 8);
21309                                   nextPC = 5 + MATCH_p; 
21310                                   
21311                                   #line 366 "machine/pentium/disassembler.m"
21312                                   
21313 
21314                                           sprintf (str,  "ROLB.Eb.Ib", DIS_EADDR8, DIS_I8);
21315 
21316                                   
21317 
21318                                   
21319                                   
21320                                   
21321                                 }
21322                                 
21323                               } /*opt-block*/
21324                               else { 
21325                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
21326                                 goto MATCH_label_a786; 
21327                                 
21328                               } /*opt-block*/
21329                               
21330                               break;
21331                             case 2: 
21332                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21333                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
21334                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21335                                       /* index at 16 */ && 
21336                                 (MATCH_w_8_16 >> 3 & 0x7) 
21337                                       /* index at 16 */ < 8)) { 
21338                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
21339                                 goto MATCH_label_a787; 
21340                                 
21341                               } /*opt-block*/
21342                               else { 
21343                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
21344                                 goto MATCH_label_a788; 
21345                                 
21346                               } /*opt-block*/
21347                               
21348                               break;
21349                             case 3: 
21350                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21351                               goto MATCH_label_a785; 
21352                               
21353                               break;
21354                             default: assert(0);
21355                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
21356                         break;
21357                       case 1: 
21358                         
21359                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
21360                             case 0: 
21361                               
21362                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
21363                                   case 0: case 1: case 2: case 3: case 6: 
21364                                   case 7: 
21365                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
21366                                     goto MATCH_label_a789; 
21367                                     
21368                                     break;
21369                                   case 4: 
21370                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
21371                                     if ((MATCH_w_8_16 & 0x7) 
21372                                             /* base at 16 */ == 5 && 
21373                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21374                                             /* index at 16 */ && 
21375                                       (MATCH_w_8_16 >> 3 & 0x7) 
21376                                             /* index at 16 */ < 8)) { 
21377                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
21378                                       goto MATCH_label_a791; 
21379                                       
21380                                     } /*opt-block*/
21381                                     else { 
21382                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
21383                                       goto MATCH_label_a790; 
21384                                       
21385                                     } /*opt-block*/
21386                                     
21387                                     break;
21388                                   case 5: 
21389                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
21390                                     goto MATCH_label_a792; 
21391                                     
21392                                     break;
21393                                   default: assert(0);
21394                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
21395                               break;
21396                             case 1: 
21397                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21398                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
21399                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21400                                       /* index at 16 */ && 
21401                                 (MATCH_w_8_16 >> 3 & 0x7) 
21402                                       /* index at 16 */ < 8)) { 
21403                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
21404                                 { 
21405                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
21406                                   int /* [~128..127] */ i8 = 
21407                                     sign_extend(
21408                                                 (MATCH_w_8_32 & 0xff) 
21409                                                       /* i8 at 32 */, 8);
21410                                   nextPC = 5 + MATCH_p; 
21411                                   
21412                                   #line 363 "machine/pentium/disassembler.m"
21413                                   
21414 
21415                                           sprintf (str,  "RORB.Eb.Ib", DIS_EADDR8, DIS_I8);
21416 
21417                                   
21418 
21419                                   
21420                                   
21421                                   
21422                                 }
21423                                 
21424                               } /*opt-block*/
21425                               else { 
21426                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
21427                                 goto MATCH_label_a790; 
21428                                 
21429                               } /*opt-block*/
21430                               
21431                               break;
21432                             case 2: 
21433                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21434                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
21435                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21436                                       /* index at 16 */ && 
21437                                 (MATCH_w_8_16 >> 3 & 0x7) 
21438                                       /* index at 16 */ < 8)) { 
21439                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
21440                                 goto MATCH_label_a791; 
21441                                 
21442                               } /*opt-block*/
21443                               else { 
21444                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
21445                                 goto MATCH_label_a792; 
21446                                 
21447                               } /*opt-block*/
21448                               
21449                               break;
21450                             case 3: 
21451                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21452                               goto MATCH_label_a789; 
21453                               
21454                               break;
21455                             default: assert(0);
21456                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
21457                         break;
21458                       case 2: 
21459                         
21460                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
21461                             case 0: 
21462                               
21463                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
21464                                   case 0: case 1: case 2: case 3: case 6: 
21465                                   case 7: 
21466                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
21467                                     goto MATCH_label_a793; 
21468                                     
21469                                     break;
21470                                   case 4: 
21471                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
21472                                     if ((MATCH_w_8_16 & 0x7) 
21473                                             /* base at 16 */ == 5 && 
21474                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21475                                             /* index at 16 */ && 
21476                                       (MATCH_w_8_16 >> 3 & 0x7) 
21477                                             /* index at 16 */ < 8)) { 
21478                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
21479                                       goto MATCH_label_a795; 
21480                                       
21481                                     } /*opt-block*/
21482                                     else { 
21483                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
21484                                       goto MATCH_label_a794; 
21485                                       
21486                                     } /*opt-block*/
21487                                     
21488                                     break;
21489                                   case 5: 
21490                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
21491                                     goto MATCH_label_a796; 
21492                                     
21493                                     break;
21494                                   default: assert(0);
21495                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
21496                               break;
21497                             case 1: 
21498                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21499                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
21500                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21501                                       /* index at 16 */ && 
21502                                 (MATCH_w_8_16 >> 3 & 0x7) 
21503                                       /* index at 16 */ < 8)) { 
21504                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
21505                                 { 
21506                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
21507                                   int /* [~128..127] */ i8 = 
21508                                     sign_extend(
21509                                                 (MATCH_w_8_32 & 0xff) 
21510                                                       /* i8 at 32 */, 8);
21511                                   nextPC = 5 + MATCH_p; 
21512                                   
21513                                   #line 360 "machine/pentium/disassembler.m"
21514                                   
21515 
21516                                           sprintf (str,  "RCLB.Eb.Ib", DIS_EADDR8, DIS_I8);
21517 
21518                                   
21519 
21520                                   
21521                                   
21522                                   
21523                                 }
21524                                 
21525                               } /*opt-block*/
21526                               else { 
21527                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
21528                                 goto MATCH_label_a794; 
21529                                 
21530                               } /*opt-block*/
21531                               
21532                               break;
21533                             case 2: 
21534                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21535                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
21536                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21537                                       /* index at 16 */ && 
21538                                 (MATCH_w_8_16 >> 3 & 0x7) 
21539                                       /* index at 16 */ < 8)) { 
21540                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
21541                                 goto MATCH_label_a795; 
21542                                 
21543                               } /*opt-block*/
21544                               else { 
21545                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
21546                                 goto MATCH_label_a796; 
21547                                 
21548                               } /*opt-block*/
21549                               
21550                               break;
21551                             case 3: 
21552                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21553                               goto MATCH_label_a793; 
21554                               
21555                               break;
21556                             default: assert(0);
21557                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
21558                         break;
21559                       case 3: 
21560                         
21561                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
21562                             case 0: 
21563                               
21564                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
21565                                   case 0: case 1: case 2: case 3: case 6: 
21566                                   case 7: 
21567                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
21568                                     goto MATCH_label_a797; 
21569                                     
21570                                     break;
21571                                   case 4: 
21572                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
21573                                     if ((MATCH_w_8_16 & 0x7) 
21574                                             /* base at 16 */ == 5 && 
21575                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21576                                             /* index at 16 */ && 
21577                                       (MATCH_w_8_16 >> 3 & 0x7) 
21578                                             /* index at 16 */ < 8)) { 
21579                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
21580                                       goto MATCH_label_a799; 
21581                                       
21582                                     } /*opt-block*/
21583                                     else { 
21584                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
21585                                       goto MATCH_label_a798; 
21586                                       
21587                                     } /*opt-block*/
21588                                     
21589                                     break;
21590                                   case 5: 
21591                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
21592                                     goto MATCH_label_a800; 
21593                                     
21594                                     break;
21595                                   default: assert(0);
21596                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
21597                               break;
21598                             case 1: 
21599                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21600                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
21601                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21602                                       /* index at 16 */ && 
21603                                 (MATCH_w_8_16 >> 3 & 0x7) 
21604                                       /* index at 16 */ < 8)) { 
21605                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
21606                                 { 
21607                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
21608                                   int /* [~128..127] */ i8 = 
21609                                     sign_extend(
21610                                                 (MATCH_w_8_32 & 0xff) 
21611                                                       /* i8 at 32 */, 8);
21612                                   nextPC = 5 + MATCH_p; 
21613                                   
21614                                   #line 357 "machine/pentium/disassembler.m"
21615                                   
21616 
21617                                           sprintf (str,  "RCRB.Eb.Ib", DIS_EADDR8, DIS_I8);
21618 
21619                                   
21620 
21621                                   
21622                                   
21623                                   
21624                                 }
21625                                 
21626                               } /*opt-block*/
21627                               else { 
21628                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
21629                                 goto MATCH_label_a798; 
21630                                 
21631                               } /*opt-block*/
21632                               
21633                               break;
21634                             case 2: 
21635                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21636                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
21637                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21638                                       /* index at 16 */ && 
21639                                 (MATCH_w_8_16 >> 3 & 0x7) 
21640                                       /* index at 16 */ < 8)) { 
21641                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
21642                                 goto MATCH_label_a799; 
21643                                 
21644                               } /*opt-block*/
21645                               else { 
21646                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
21647                                 goto MATCH_label_a800; 
21648                                 
21649                               } /*opt-block*/
21650                               
21651                               break;
21652                             case 3: 
21653                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21654                               goto MATCH_label_a797; 
21655                               
21656                               break;
21657                             default: assert(0);
21658                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
21659                         break;
21660                       case 4: 
21661                         
21662                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
21663                             case 0: 
21664                               
21665                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
21666                                   case 0: case 1: case 2: case 3: case 6: 
21667                                   case 7: 
21668                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
21669                                     goto MATCH_label_a801; 
21670                                     
21671                                     break;
21672                                   case 4: 
21673                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
21674                                     if ((MATCH_w_8_16 & 0x7) 
21675                                             /* base at 16 */ == 5 && 
21676                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21677                                             /* index at 16 */ && 
21678                                       (MATCH_w_8_16 >> 3 & 0x7) 
21679                                             /* index at 16 */ < 8)) { 
21680                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
21681                                       goto MATCH_label_a803; 
21682                                       
21683                                     } /*opt-block*/
21684                                     else { 
21685                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
21686                                       goto MATCH_label_a802; 
21687                                       
21688                                     } /*opt-block*/
21689                                     
21690                                     break;
21691                                   case 5: 
21692                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
21693                                     goto MATCH_label_a804; 
21694                                     
21695                                     break;
21696                                   default: assert(0);
21697                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
21698                               break;
21699                             case 1: 
21700                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21701                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
21702                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21703                                       /* index at 16 */ && 
21704                                 (MATCH_w_8_16 >> 3 & 0x7) 
21705                                       /* index at 16 */ < 8)) { 
21706                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
21707                                 { 
21708                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
21709                                   int /* [~128..127] */ i8 = 
21710                                     sign_extend(
21711                                                 (MATCH_w_8_32 & 0xff) 
21712                                                       /* i8 at 32 */, 8);
21713                                   nextPC = 5 + MATCH_p; 
21714                                   
21715                                   #line 354 "machine/pentium/disassembler.m"
21716                                   
21717 
21718                                           sprintf (str,  "SHLSALB.Eb.Ib", DIS_EADDR8, DIS_I8);
21719 
21720                                   
21721 
21722                                   
21723                                   
21724                                   
21725                                 }
21726                                 
21727                               } /*opt-block*/
21728                               else { 
21729                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
21730                                 goto MATCH_label_a802; 
21731                                 
21732                               } /*opt-block*/
21733                               
21734                               break;
21735                             case 2: 
21736                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21737                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
21738                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21739                                       /* index at 16 */ && 
21740                                 (MATCH_w_8_16 >> 3 & 0x7) 
21741                                       /* index at 16 */ < 8)) { 
21742                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
21743                                 goto MATCH_label_a803; 
21744                                 
21745                               } /*opt-block*/
21746                               else { 
21747                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
21748                                 goto MATCH_label_a804; 
21749                                 
21750                               } /*opt-block*/
21751                               
21752                               break;
21753                             case 3: 
21754                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21755                               goto MATCH_label_a801; 
21756                               
21757                               break;
21758                             default: assert(0);
21759                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
21760                         break;
21761                       case 5: 
21762                         
21763                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
21764                             case 0: 
21765                               
21766                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
21767                                   case 0: case 1: case 2: case 3: case 6: 
21768                                   case 7: 
21769                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
21770                                     goto MATCH_label_a805; 
21771                                     
21772                                     break;
21773                                   case 4: 
21774                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
21775                                     if ((MATCH_w_8_16 & 0x7) 
21776                                             /* base at 16 */ == 5 && 
21777                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21778                                             /* index at 16 */ && 
21779                                       (MATCH_w_8_16 >> 3 & 0x7) 
21780                                             /* index at 16 */ < 8)) { 
21781                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
21782                                       goto MATCH_label_a807; 
21783                                       
21784                                     } /*opt-block*/
21785                                     else { 
21786                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
21787                                       goto MATCH_label_a806; 
21788                                       
21789                                     } /*opt-block*/
21790                                     
21791                                     break;
21792                                   case 5: 
21793                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
21794                                     goto MATCH_label_a808; 
21795                                     
21796                                     break;
21797                                   default: assert(0);
21798                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
21799                               break;
21800                             case 1: 
21801                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21802                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
21803                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21804                                       /* index at 16 */ && 
21805                                 (MATCH_w_8_16 >> 3 & 0x7) 
21806                                       /* index at 16 */ < 8)) { 
21807                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
21808                                 { 
21809                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
21810                                   int /* [~128..127] */ i8 = 
21811                                     sign_extend(
21812                                                 (MATCH_w_8_32 & 0xff) 
21813                                                       /* i8 at 32 */, 8);
21814                                   nextPC = 5 + MATCH_p; 
21815                                   
21816                                   #line 351 "machine/pentium/disassembler.m"
21817                                   
21818 
21819                                           sprintf (str,  "SHRB.Eb.Ib", DIS_EADDR8, DIS_I8);
21820 
21821                                   
21822 
21823                                   
21824                                   
21825                                   
21826                                 }
21827                                 
21828                               } /*opt-block*/
21829                               else { 
21830                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
21831                                 goto MATCH_label_a806; 
21832                                 
21833                               } /*opt-block*/
21834                               
21835                               break;
21836                             case 2: 
21837                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21838                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
21839                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21840                                       /* index at 16 */ && 
21841                                 (MATCH_w_8_16 >> 3 & 0x7) 
21842                                       /* index at 16 */ < 8)) { 
21843                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
21844                                 goto MATCH_label_a807; 
21845                                 
21846                               } /*opt-block*/
21847                               else { 
21848                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
21849                                 goto MATCH_label_a808; 
21850                                 
21851                               } /*opt-block*/
21852                               
21853                               break;
21854                             case 3: 
21855                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21856                               goto MATCH_label_a805; 
21857                               
21858                               break;
21859                             default: assert(0);
21860                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
21861                         break;
21862                       case 6: 
21863                         goto MATCH_label_a39; break;
21864                       case 7: 
21865                         
21866                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
21867                             case 0: 
21868                               
21869                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
21870                                   case 0: case 1: case 2: case 3: case 6: 
21871                                   case 7: 
21872                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
21873                                     goto MATCH_label_a809; 
21874                                     
21875                                     break;
21876                                   case 4: 
21877                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
21878                                     if ((MATCH_w_8_16 & 0x7) 
21879                                             /* base at 16 */ == 5 && 
21880                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21881                                             /* index at 16 */ && 
21882                                       (MATCH_w_8_16 >> 3 & 0x7) 
21883                                             /* index at 16 */ < 8)) { 
21884                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
21885                                       goto MATCH_label_a811; 
21886                                       
21887                                     } /*opt-block*/
21888                                     else { 
21889                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
21890                                       goto MATCH_label_a810; 
21891                                       
21892                                     } /*opt-block*/
21893                                     
21894                                     break;
21895                                   case 5: 
21896                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
21897                                     goto MATCH_label_a812; 
21898                                     
21899                                     break;
21900                                   default: assert(0);
21901                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
21902                               break;
21903                             case 1: 
21904                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21905                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
21906                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21907                                       /* index at 16 */ && 
21908                                 (MATCH_w_8_16 >> 3 & 0x7) 
21909                                       /* index at 16 */ < 8)) { 
21910                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
21911                                 { 
21912                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
21913                                   int /* [~128..127] */ i8 = 
21914                                     sign_extend(
21915                                                 (MATCH_w_8_32 & 0xff) 
21916                                                       /* i8 at 32 */, 8);
21917                                   nextPC = 5 + MATCH_p; 
21918                                   
21919                                   #line 348 "machine/pentium/disassembler.m"
21920                                   
21921 
21922                                           sprintf (str,  "SARB.Eb.Ib", DIS_EADDR8, DIS_I8);
21923 
21924                                   
21925 
21926                                   
21927                                   
21928                                   
21929                                 }
21930                                 
21931                               } /*opt-block*/
21932                               else { 
21933                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
21934                                 goto MATCH_label_a810; 
21935                                 
21936                               } /*opt-block*/
21937                               
21938                               break;
21939                             case 2: 
21940                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21941                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
21942                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21943                                       /* index at 16 */ && 
21944                                 (MATCH_w_8_16 >> 3 & 0x7) 
21945                                       /* index at 16 */ < 8)) { 
21946                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
21947                                 goto MATCH_label_a811; 
21948                                 
21949                               } /*opt-block*/
21950                               else { 
21951                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
21952                                 goto MATCH_label_a812; 
21953                                 
21954                               } /*opt-block*/
21955                               
21956                               break;
21957                             case 3: 
21958                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
21959                               goto MATCH_label_a809; 
21960                               
21961                               break;
21962                             default: assert(0);
21963                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
21964                         break;
21965                       default: assert(0);
21966                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
21967                   
21968                   break;
21969                 case 1: 
21970                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
21971                   
21972                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
21973                       case 0: 
21974                         
21975                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
21976                             case 0: 
21977                               
21978                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
21979                                   case 0: case 1: case 2: case 3: case 6: 
21980                                   case 7: 
21981                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
21982                                     goto MATCH_label_a813; 
21983                                     
21984                                     break;
21985                                   case 4: 
21986                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
21987                                     if ((MATCH_w_8_16 & 0x7) 
21988                                             /* base at 16 */ == 5 && 
21989                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
21990                                             /* index at 16 */ && 
21991                                       (MATCH_w_8_16 >> 3 & 0x7) 
21992                                             /* index at 16 */ < 8)) { 
21993                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
21994                                       goto MATCH_label_a815; 
21995                                       
21996                                     } /*opt-block*/
21997                                     else { 
21998                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
21999                                       goto MATCH_label_a814; 
22000                                       
22001                                     } /*opt-block*/
22002                                     
22003                                     break;
22004                                   case 5: 
22005                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
22006                                     goto MATCH_label_a816; 
22007                                     
22008                                     break;
22009                                   default: assert(0);
22010                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
22011                               break;
22012                             case 1: 
22013                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22014                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22015                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22016                                       /* index at 16 */ && 
22017                                 (MATCH_w_8_16 >> 3 & 0x7) 
22018                                       /* index at 16 */ < 8)) { 
22019                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
22020                                 { 
22021                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
22022                                   int /* [~128..127] */ i8 = 
22023                                     sign_extend(
22024                                                 (MATCH_w_8_32 & 0xff) 
22025                                                       /* i8 at 32 */, 8);
22026                                   nextPC = 5 + MATCH_p; 
22027                                   
22028                                   #line 342 "machine/pentium/disassembler.m"
22029                                   
22030 
22031                                           sprintf (str,  "ROLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
22032 
22033                                   
22034 
22035                                   
22036                                   
22037                                   
22038                                 }
22039                                 
22040                               } /*opt-block*/
22041                               else { 
22042                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
22043                                 goto MATCH_label_a814; 
22044                                 
22045                               } /*opt-block*/
22046                               
22047                               break;
22048                             case 2: 
22049                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22050                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22051                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22052                                       /* index at 16 */ && 
22053                                 (MATCH_w_8_16 >> 3 & 0x7) 
22054                                       /* index at 16 */ < 8)) { 
22055                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
22056                                 goto MATCH_label_a815; 
22057                                 
22058                               } /*opt-block*/
22059                               else { 
22060                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
22061                                 goto MATCH_label_a816; 
22062                                 
22063                               } /*opt-block*/
22064                               
22065                               break;
22066                             case 3: 
22067                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22068                               goto MATCH_label_a813; 
22069                               
22070                               break;
22071                             default: assert(0);
22072                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
22073                         break;
22074                       case 1: 
22075                         
22076                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
22077                             case 0: 
22078                               
22079                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
22080                                   case 0: case 1: case 2: case 3: case 6: 
22081                                   case 7: 
22082                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
22083                                     goto MATCH_label_a817; 
22084                                     
22085                                     break;
22086                                   case 4: 
22087                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
22088                                     if ((MATCH_w_8_16 & 0x7) 
22089                                             /* base at 16 */ == 5 && 
22090                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22091                                             /* index at 16 */ && 
22092                                       (MATCH_w_8_16 >> 3 & 0x7) 
22093                                             /* index at 16 */ < 8)) { 
22094                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
22095                                       goto MATCH_label_a819; 
22096                                       
22097                                     } /*opt-block*/
22098                                     else { 
22099                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
22100                                       goto MATCH_label_a818; 
22101                                       
22102                                     } /*opt-block*/
22103                                     
22104                                     break;
22105                                   case 5: 
22106                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
22107                                     goto MATCH_label_a820; 
22108                                     
22109                                     break;
22110                                   default: assert(0);
22111                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
22112                               break;
22113                             case 1: 
22114                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22115                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22116                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22117                                       /* index at 16 */ && 
22118                                 (MATCH_w_8_16 >> 3 & 0x7) 
22119                                       /* index at 16 */ < 8)) { 
22120                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
22121                                 { 
22122                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
22123                                   int /* [~128..127] */ i8 = 
22124                                     sign_extend(
22125                                                 (MATCH_w_8_32 & 0xff) 
22126                                                       /* i8 at 32 */, 8);
22127                                   nextPC = 5 + MATCH_p; 
22128                                   
22129                                   #line 336 "machine/pentium/disassembler.m"
22130                                   
22131 
22132                                           sprintf (str,  "RORB.Ev.Ibod", DIS_EADDR32, DIS_I8);
22133 
22134                                   
22135 
22136                                   
22137                                   
22138                                   
22139                                 }
22140                                 
22141                               } /*opt-block*/
22142                               else { 
22143                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
22144                                 goto MATCH_label_a818; 
22145                                 
22146                               } /*opt-block*/
22147                               
22148                               break;
22149                             case 2: 
22150                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22151                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22152                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22153                                       /* index at 16 */ && 
22154                                 (MATCH_w_8_16 >> 3 & 0x7) 
22155                                       /* index at 16 */ < 8)) { 
22156                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
22157                                 goto MATCH_label_a819; 
22158                                 
22159                               } /*opt-block*/
22160                               else { 
22161                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
22162                                 goto MATCH_label_a820; 
22163                                 
22164                               } /*opt-block*/
22165                               
22166                               break;
22167                             case 3: 
22168                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22169                               goto MATCH_label_a817; 
22170                               
22171                               break;
22172                             default: assert(0);
22173                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
22174                         break;
22175                       case 2: 
22176                         
22177                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
22178                             case 0: 
22179                               
22180                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
22181                                   case 0: case 1: case 2: case 3: case 6: 
22182                                   case 7: 
22183                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
22184                                     goto MATCH_label_a821; 
22185                                     
22186                                     break;
22187                                   case 4: 
22188                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
22189                                     if ((MATCH_w_8_16 & 0x7) 
22190                                             /* base at 16 */ == 5 && 
22191                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22192                                             /* index at 16 */ && 
22193                                       (MATCH_w_8_16 >> 3 & 0x7) 
22194                                             /* index at 16 */ < 8)) { 
22195                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
22196                                       goto MATCH_label_a823; 
22197                                       
22198                                     } /*opt-block*/
22199                                     else { 
22200                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
22201                                       goto MATCH_label_a822; 
22202                                       
22203                                     } /*opt-block*/
22204                                     
22205                                     break;
22206                                   case 5: 
22207                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
22208                                     goto MATCH_label_a824; 
22209                                     
22210                                     break;
22211                                   default: assert(0);
22212                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
22213                               break;
22214                             case 1: 
22215                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22216                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22217                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22218                                       /* index at 16 */ && 
22219                                 (MATCH_w_8_16 >> 3 & 0x7) 
22220                                       /* index at 16 */ < 8)) { 
22221                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
22222                                 { 
22223                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
22224                                   int /* [~128..127] */ i8 = 
22225                                     sign_extend(
22226                                                 (MATCH_w_8_32 & 0xff) 
22227                                                       /* i8 at 32 */, 8);
22228                                   nextPC = 5 + MATCH_p; 
22229                                   
22230                                   #line 330 "machine/pentium/disassembler.m"
22231                                   
22232 
22233                                           sprintf (str,  "RCLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
22234 
22235                                   
22236 
22237                                   
22238                                   
22239                                   
22240                                 }
22241                                 
22242                               } /*opt-block*/
22243                               else { 
22244                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
22245                                 goto MATCH_label_a822; 
22246                                 
22247                               } /*opt-block*/
22248                               
22249                               break;
22250                             case 2: 
22251                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22252                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22253                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22254                                       /* index at 16 */ && 
22255                                 (MATCH_w_8_16 >> 3 & 0x7) 
22256                                       /* index at 16 */ < 8)) { 
22257                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
22258                                 goto MATCH_label_a823; 
22259                                 
22260                               } /*opt-block*/
22261                               else { 
22262                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
22263                                 goto MATCH_label_a824; 
22264                                 
22265                               } /*opt-block*/
22266                               
22267                               break;
22268                             case 3: 
22269                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22270                               goto MATCH_label_a821; 
22271                               
22272                               break;
22273                             default: assert(0);
22274                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
22275                         break;
22276                       case 3: 
22277                         
22278                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
22279                             case 0: 
22280                               
22281                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
22282                                   case 0: case 1: case 2: case 3: case 6: 
22283                                   case 7: 
22284                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
22285                                     goto MATCH_label_a825; 
22286                                     
22287                                     break;
22288                                   case 4: 
22289                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
22290                                     if ((MATCH_w_8_16 & 0x7) 
22291                                             /* base at 16 */ == 5 && 
22292                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22293                                             /* index at 16 */ && 
22294                                       (MATCH_w_8_16 >> 3 & 0x7) 
22295                                             /* index at 16 */ < 8)) { 
22296                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
22297                                       goto MATCH_label_a827; 
22298                                       
22299                                     } /*opt-block*/
22300                                     else { 
22301                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
22302                                       goto MATCH_label_a826; 
22303                                       
22304                                     } /*opt-block*/
22305                                     
22306                                     break;
22307                                   case 5: 
22308                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
22309                                     goto MATCH_label_a828; 
22310                                     
22311                                     break;
22312                                   default: assert(0);
22313                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
22314                               break;
22315                             case 1: 
22316                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22317                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22318                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22319                                       /* index at 16 */ && 
22320                                 (MATCH_w_8_16 >> 3 & 0x7) 
22321                                       /* index at 16 */ < 8)) { 
22322                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
22323                                 { 
22324                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
22325                                   int /* [~128..127] */ i8 = 
22326                                     sign_extend(
22327                                                 (MATCH_w_8_32 & 0xff) 
22328                                                       /* i8 at 32 */, 8);
22329                                   nextPC = 5 + MATCH_p; 
22330                                   
22331                                   #line 324 "machine/pentium/disassembler.m"
22332                                   
22333 
22334                                           sprintf (str,  "RCRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
22335 
22336                                   
22337 
22338                                   
22339                                   
22340                                   
22341                                 }
22342                                 
22343                               } /*opt-block*/
22344                               else { 
22345                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
22346                                 goto MATCH_label_a826; 
22347                                 
22348                               } /*opt-block*/
22349                               
22350                               break;
22351                             case 2: 
22352                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22353                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22354                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22355                                       /* index at 16 */ && 
22356                                 (MATCH_w_8_16 >> 3 & 0x7) 
22357                                       /* index at 16 */ < 8)) { 
22358                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
22359                                 goto MATCH_label_a827; 
22360                                 
22361                               } /*opt-block*/
22362                               else { 
22363                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
22364                                 goto MATCH_label_a828; 
22365                                 
22366                               } /*opt-block*/
22367                               
22368                               break;
22369                             case 3: 
22370                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22371                               goto MATCH_label_a825; 
22372                               
22373                               break;
22374                             default: assert(0);
22375                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
22376                         break;
22377                       case 4: 
22378                         
22379                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
22380                             case 0: 
22381                               
22382                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
22383                                   case 0: case 1: case 2: case 3: case 6: 
22384                                   case 7: 
22385                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
22386                                     goto MATCH_label_a829; 
22387                                     
22388                                     break;
22389                                   case 4: 
22390                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
22391                                     if ((MATCH_w_8_16 & 0x7) 
22392                                             /* base at 16 */ == 5 && 
22393                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22394                                             /* index at 16 */ && 
22395                                       (MATCH_w_8_16 >> 3 & 0x7) 
22396                                             /* index at 16 */ < 8)) { 
22397                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
22398                                       goto MATCH_label_a831; 
22399                                       
22400                                     } /*opt-block*/
22401                                     else { 
22402                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
22403                                       goto MATCH_label_a830; 
22404                                       
22405                                     } /*opt-block*/
22406                                     
22407                                     break;
22408                                   case 5: 
22409                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
22410                                     goto MATCH_label_a832; 
22411                                     
22412                                     break;
22413                                   default: assert(0);
22414                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
22415                               break;
22416                             case 1: 
22417                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22418                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22419                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22420                                       /* index at 16 */ && 
22421                                 (MATCH_w_8_16 >> 3 & 0x7) 
22422                                       /* index at 16 */ < 8)) { 
22423                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
22424                                 { 
22425                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
22426                                   int /* [~128..127] */ i8 = 
22427                                     sign_extend(
22428                                                 (MATCH_w_8_32 & 0xff) 
22429                                                       /* i8 at 32 */, 8);
22430                                   nextPC = 5 + MATCH_p; 
22431                                   
22432                                   #line 318 "machine/pentium/disassembler.m"
22433                                   
22434 
22435                                           sprintf (str,  "SHLSALB.Ev.Ibod", DIS_EADDR32, DIS_I8);
22436 
22437                                   
22438 
22439                                   
22440                                   
22441                                   
22442                                 }
22443                                 
22444                               } /*opt-block*/
22445                               else { 
22446                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
22447                                 goto MATCH_label_a830; 
22448                                 
22449                               } /*opt-block*/
22450                               
22451                               break;
22452                             case 2: 
22453                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22454                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22455                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22456                                       /* index at 16 */ && 
22457                                 (MATCH_w_8_16 >> 3 & 0x7) 
22458                                       /* index at 16 */ < 8)) { 
22459                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
22460                                 goto MATCH_label_a831; 
22461                                 
22462                               } /*opt-block*/
22463                               else { 
22464                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
22465                                 goto MATCH_label_a832; 
22466                                 
22467                               } /*opt-block*/
22468                               
22469                               break;
22470                             case 3: 
22471                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22472                               goto MATCH_label_a829; 
22473                               
22474                               break;
22475                             default: assert(0);
22476                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
22477                         break;
22478                       case 5: 
22479                         
22480                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
22481                             case 0: 
22482                               
22483                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
22484                                   case 0: case 1: case 2: case 3: case 6: 
22485                                   case 7: 
22486                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
22487                                     goto MATCH_label_a833; 
22488                                     
22489                                     break;
22490                                   case 4: 
22491                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
22492                                     if ((MATCH_w_8_16 & 0x7) 
22493                                             /* base at 16 */ == 5 && 
22494                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22495                                             /* index at 16 */ && 
22496                                       (MATCH_w_8_16 >> 3 & 0x7) 
22497                                             /* index at 16 */ < 8)) { 
22498                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
22499                                       goto MATCH_label_a835; 
22500                                       
22501                                     } /*opt-block*/
22502                                     else { 
22503                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
22504                                       goto MATCH_label_a834; 
22505                                       
22506                                     } /*opt-block*/
22507                                     
22508                                     break;
22509                                   case 5: 
22510                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
22511                                     goto MATCH_label_a836; 
22512                                     
22513                                     break;
22514                                   default: assert(0);
22515                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
22516                               break;
22517                             case 1: 
22518                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22519                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22520                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22521                                       /* index at 16 */ && 
22522                                 (MATCH_w_8_16 >> 3 & 0x7) 
22523                                       /* index at 16 */ < 8)) { 
22524                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
22525                                 { 
22526                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
22527                                   int /* [~128..127] */ i8 = 
22528                                     sign_extend(
22529                                                 (MATCH_w_8_32 & 0xff) 
22530                                                       /* i8 at 32 */, 8);
22531                                   nextPC = 5 + MATCH_p; 
22532                                   
22533                                   #line 312 "machine/pentium/disassembler.m"
22534                                   
22535 
22536                                           sprintf (str,  "SHRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
22537 
22538                                   
22539 
22540                                   
22541                                   
22542                                   
22543                                 }
22544                                 
22545                               } /*opt-block*/
22546                               else { 
22547                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
22548                                 goto MATCH_label_a834; 
22549                                 
22550                               } /*opt-block*/
22551                               
22552                               break;
22553                             case 2: 
22554                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22555                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22556                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22557                                       /* index at 16 */ && 
22558                                 (MATCH_w_8_16 >> 3 & 0x7) 
22559                                       /* index at 16 */ < 8)) { 
22560                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
22561                                 goto MATCH_label_a835; 
22562                                 
22563                               } /*opt-block*/
22564                               else { 
22565                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
22566                                 goto MATCH_label_a836; 
22567                                 
22568                               } /*opt-block*/
22569                               
22570                               break;
22571                             case 3: 
22572                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22573                               goto MATCH_label_a833; 
22574                               
22575                               break;
22576                             default: assert(0);
22577                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
22578                         break;
22579                       case 6: 
22580                         goto MATCH_label_a39; break;
22581                       case 7: 
22582                         
22583                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
22584                             case 0: 
22585                               
22586                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
22587                                   case 0: case 1: case 2: case 3: case 6: 
22588                                   case 7: 
22589                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
22590                                     goto MATCH_label_a837; 
22591                                     
22592                                     break;
22593                                   case 4: 
22594                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
22595                                     if ((MATCH_w_8_16 & 0x7) 
22596                                             /* base at 16 */ == 5 && 
22597                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22598                                             /* index at 16 */ && 
22599                                       (MATCH_w_8_16 >> 3 & 0x7) 
22600                                             /* index at 16 */ < 8)) { 
22601                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
22602                                       goto MATCH_label_a839; 
22603                                       
22604                                     } /*opt-block*/
22605                                     else { 
22606                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
22607                                       goto MATCH_label_a838; 
22608                                       
22609                                     } /*opt-block*/
22610                                     
22611                                     break;
22612                                   case 5: 
22613                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
22614                                     goto MATCH_label_a840; 
22615                                     
22616                                     break;
22617                                   default: assert(0);
22618                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
22619                               break;
22620                             case 1: 
22621                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22622                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22623                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22624                                       /* index at 16 */ && 
22625                                 (MATCH_w_8_16 >> 3 & 0x7) 
22626                                       /* index at 16 */ < 8)) { 
22627                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
22628                                 { 
22629                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
22630                                   int /* [~128..127] */ i8 = 
22631                                     sign_extend(
22632                                                 (MATCH_w_8_32 & 0xff) 
22633                                                       /* i8 at 32 */, 8);
22634                                   nextPC = 5 + MATCH_p; 
22635                                   
22636                                   #line 306 "machine/pentium/disassembler.m"
22637                                   
22638 
22639                                           sprintf (str,  "SARB.Ev.Ibod", DIS_EADDR32, DIS_I8);
22640 
22641                                   
22642 
22643                                   
22644                                   
22645                                   
22646                                 }
22647                                 
22648                               } /*opt-block*/
22649                               else { 
22650                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
22651                                 goto MATCH_label_a838; 
22652                                 
22653                               } /*opt-block*/
22654                               
22655                               break;
22656                             case 2: 
22657                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22658                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22659                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22660                                       /* index at 16 */ && 
22661                                 (MATCH_w_8_16 >> 3 & 0x7) 
22662                                       /* index at 16 */ < 8)) { 
22663                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
22664                                 goto MATCH_label_a839; 
22665                                 
22666                               } /*opt-block*/
22667                               else { 
22668                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
22669                                 goto MATCH_label_a840; 
22670                                 
22671                               } /*opt-block*/
22672                               
22673                               break;
22674                             case 3: 
22675                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22676                               goto MATCH_label_a837; 
22677                               
22678                               break;
22679                             default: assert(0);
22680                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
22681                         break;
22682                       default: assert(0);
22683                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
22684                   
22685                   break;
22686                 case 2: 
22687                   MATCH_w_16_8 = getWord(1 + MATCH_p); 
22688                   { 
22689                     unsigned i16 = (MATCH_w_16_8 & 0xffff) /* i16 at 8 */;
22690                     nextPC = 3 + MATCH_p; 
22691                     
22692                     #line 198 "machine/pentium/disassembler.m"
22693                     
22694 
22695                             sprintf (str,  "RET.Iw", DIS_I16);
22696 
22697                     
22698 
22699                     
22700                     
22701                     
22702                   }
22703                   
22704                   break;
22705                 case 3: 
22706                   nextPC = 1 + MATCH_p; 
22707                   
22708                   #line 204 "machine/pentium/disassembler.m"
22709                   
22710 
22711                           sprintf (str,  "RET");
22712 
22713                   
22714 
22715                   //   | REPNE() =>
22716 
22717                   //      sprintf (str,  "REPNE");
22718 
22719                   
22720 
22721                   //  | REP() =>
22722 
22723                   //      sprintf (str,  "REP");
22724 
22725                   
22726 
22727                   
22728                   
22729                   
22730                   
22731                   break;
22732                 case 4: 
22733                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
22734                   
22735                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
22736                       case 0: 
22737                         
22738                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
22739                             case 0: case 1: case 2: case 3: case 6: case 7: 
22740                               { 
22741                                 unsigned Mem = 1 + addressToPC(MATCH_p);
22742                                 unsigned reg = 
22743                                   (MATCH_w_8_8 >> 3 & 0x7) 
22744                                         /* reg_opcode at 8 */;
22745                                 nextPC = 2 + MATCH_p; 
22746                                 
22747                                 #line 772 "machine/pentium/disassembler.m"
22748                                 
22749 
22750                                         sprintf (str,  "LES", DIS_REG32, DIS_MEM);
22751 
22752                                 
22753 
22754                                 
22755                                 
22756                                 
22757                               }
22758                               
22759                               break;
22760                             case 4: 
22761                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22762                               if ((MATCH_w_8_16 & 0x7) 
22763                                       /* base at 16 */ == 5 && 
22764                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22765                                       /* index at 16 */ && 
22766                                 (MATCH_w_8_16 >> 3 & 0x7) 
22767                                       /* index at 16 */ < 8)) 
22768                                 goto MATCH_label_a842;  /*opt-block+*/
22769                               else 
22770                                 goto MATCH_label_a841;  /*opt-block+*/
22771                               
22772                               break;
22773                             case 5: 
22774                               goto MATCH_label_a843; break;
22775                             default: assert(0);
22776                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
22777                         break;
22778                       case 1: 
22779                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
22780                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22781                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22782                                 /* index at 16 */ && 
22783                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
22784                           unsigned Mem = 1 + addressToPC(MATCH_p);
22785                           unsigned reg = 
22786                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
22787                           nextPC = 4 + MATCH_p; 
22788                           
22789                           #line 772 "machine/pentium/disassembler.m"
22790                           
22791 
22792                                   sprintf (str,  "LES", DIS_REG32, DIS_MEM);
22793 
22794                           
22795 
22796                           
22797                           
22798                           
22799                         } /*opt-block*//*opt-block+*/
22800                         else 
22801                           goto MATCH_label_a841;  /*opt-block+*/
22802                         
22803                         break;
22804                       case 2: 
22805                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
22806                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22807                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22808                                 /* index at 16 */ && 
22809                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
22810                           goto MATCH_label_a842;  /*opt-block+*/
22811                         else 
22812                           goto MATCH_label_a843;  /*opt-block+*/
22813                         
22814                         break;
22815                       case 3: 
22816                         goto MATCH_label_a39; break;
22817                       default: assert(0);
22818                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
22819                   
22820                   break;
22821                 case 5: 
22822                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
22823                   
22824                     switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
22825                       case 0: 
22826                         
22827                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
22828                             case 0: case 1: case 2: case 3: case 6: case 7: 
22829                               { 
22830                                 unsigned Mem = 1 + addressToPC(MATCH_p);
22831                                 unsigned reg = 
22832                                   (MATCH_w_8_8 >> 3 & 0x7) 
22833                                         /* reg_opcode at 8 */;
22834                                 nextPC = 2 + MATCH_p; 
22835                                 
22836                                 #line 784 "machine/pentium/disassembler.m"
22837                                 
22838 
22839                                         sprintf (str,  "LDS", DIS_REG32, DIS_MEM);
22840 
22841                                 
22842 
22843                                 
22844                                 
22845                                 
22846                               }
22847                               
22848                               break;
22849                             case 4: 
22850                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
22851                               if ((MATCH_w_8_16 & 0x7) 
22852                                       /* base at 16 */ == 5 && 
22853                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22854                                       /* index at 16 */ && 
22855                                 (MATCH_w_8_16 >> 3 & 0x7) 
22856                                       /* index at 16 */ < 8)) 
22857                                 goto MATCH_label_a845;  /*opt-block+*/
22858                               else 
22859                                 goto MATCH_label_a844;  /*opt-block+*/
22860                               
22861                               break;
22862                             case 5: 
22863                               goto MATCH_label_a846; break;
22864                             default: assert(0);
22865                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
22866                         break;
22867                       case 1: 
22868                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
22869                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22870                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22871                                 /* index at 16 */ && 
22872                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) { 
22873                           unsigned Mem = 1 + addressToPC(MATCH_p);
22874                           unsigned reg = 
22875                             (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
22876                           nextPC = 4 + MATCH_p; 
22877                           
22878                           #line 784 "machine/pentium/disassembler.m"
22879                           
22880 
22881                                   sprintf (str,  "LDS", DIS_REG32, DIS_MEM);
22882 
22883                           
22884 
22885                           
22886                           
22887                           
22888                         } /*opt-block*//*opt-block+*/
22889                         else 
22890                           goto MATCH_label_a844;  /*opt-block+*/
22891                         
22892                         break;
22893                       case 2: 
22894                         MATCH_w_8_16 = getByte(2 + MATCH_p); 
22895                         if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22896                           (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22897                                 /* index at 16 */ && 
22898                           (MATCH_w_8_16 >> 3 & 0x7) /* index at 16 */ < 8)) 
22899                           goto MATCH_label_a845;  /*opt-block+*/
22900                         else 
22901                           goto MATCH_label_a846;  /*opt-block+*/
22902                         
22903                         break;
22904                       case 3: 
22905                         goto MATCH_label_a39; break;
22906                       default: assert(0);
22907                     } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
22908                   
22909                   break;
22910                 case 6: 
22911                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
22912                   if ((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */ == 0) 
22913                     
22914                       switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
22915                         case 0: 
22916                           
22917                             switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
22918                               case 0: case 1: case 2: case 3: case 6: case 7: 
22919                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
22920                                 goto MATCH_label_a847; 
22921                                 
22922                                 break;
22923                               case 4: 
22924                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
22925                                 if ((MATCH_w_8_16 & 0x7) 
22926                                         /* base at 16 */ == 5 && 
22927                                   (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22928                                         /* index at 16 */ && 
22929                                   (MATCH_w_8_16 >> 3 & 0x7) 
22930                                         /* index at 16 */ < 8)) { 
22931                                   MATCH_w_8_56 = getByte(7 + MATCH_p); 
22932                                   goto MATCH_label_a849; 
22933                                   
22934                                 } /*opt-block*/
22935                                 else { 
22936                                   MATCH_w_8_24 = getByte(3 + MATCH_p); 
22937                                   goto MATCH_label_a848; 
22938                                   
22939                                 } /*opt-block*/
22940                                 
22941                                 break;
22942                               case 5: 
22943                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
22944                                 goto MATCH_label_a850; 
22945                                 
22946                                 break;
22947                               default: assert(0);
22948                             } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
22949                           break;
22950                         case 1: 
22951                           MATCH_w_8_16 = getByte(2 + MATCH_p); 
22952                           if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22953                             (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22954                                   /* index at 16 */ && 
22955                             (MATCH_w_8_16 >> 3 & 0x7) 
22956                                   /* index at 16 */ < 8)) { 
22957                             MATCH_w_8_32 = getByte(4 + MATCH_p); 
22958                             { 
22959                               unsigned Eaddr = 1 + addressToPC(MATCH_p);
22960                               int /* [~128..127] */ i8 = 
22961                                 sign_extend(
22962                                             (MATCH_w_8_32 & 0xff) 
22963                                                   /* i8 at 32 */, 8);
22964                               nextPC = 5 + MATCH_p; 
22965                               
22966                               #line 691 "machine/pentium/disassembler.m"
22967                               
22968 
22969                                       sprintf (str,  "MOV.Eb.Ib", DIS_EADDR8, DIS_I8);
22970 
22971                               
22972 
22973                               
22974                               
22975                               
22976                             }
22977                             
22978                           } /*opt-block*/
22979                           else { 
22980                             MATCH_w_8_24 = getByte(3 + MATCH_p); 
22981                             goto MATCH_label_a848; 
22982                             
22983                           } /*opt-block*/
22984                           
22985                           break;
22986                         case 2: 
22987                           MATCH_w_8_16 = getByte(2 + MATCH_p); 
22988                           if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
22989                             (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
22990                                   /* index at 16 */ && 
22991                             (MATCH_w_8_16 >> 3 & 0x7) 
22992                                   /* index at 16 */ < 8)) { 
22993                             MATCH_w_8_56 = getByte(7 + MATCH_p); 
22994                             goto MATCH_label_a849; 
22995                             
22996                           } /*opt-block*/
22997                           else { 
22998                             MATCH_w_8_48 = getByte(6 + MATCH_p); 
22999                             goto MATCH_label_a850; 
23000                             
23001                           } /*opt-block*/
23002                           
23003                           break;
23004                         case 3: 
23005                           MATCH_w_8_16 = getByte(2 + MATCH_p); 
23006                           goto MATCH_label_a847; 
23007                           
23008                           break;
23009                         default: assert(0);
23010                       } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/  
23011                   else 
23012                     goto MATCH_label_a39;  /*opt-block+*/
23013                   
23014                   break;
23015                 case 7: 
23016                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
23017                   if ((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */ == 0) 
23018                     
23019                       switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
23020                         case 0: 
23021                           
23022                             switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
23023                               case 0: case 1: case 2: case 3: case 6: case 7: 
23024                                 MATCH_w_32_16 = getDword(2 + MATCH_p); 
23025                                 goto MATCH_label_a851; 
23026                                 
23027                                 break;
23028                               case 4: 
23029                                 MATCH_w_8_16 = getByte(2 + MATCH_p); 
23030                                 if ((MATCH_w_8_16 & 0x7) 
23031                                         /* base at 16 */ == 5 && 
23032                                   (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23033                                         /* index at 16 */ && 
23034                                   (MATCH_w_8_16 >> 3 & 0x7) 
23035                                         /* index at 16 */ < 8)) { 
23036                                   MATCH_w_32_56 = getDword(7 + MATCH_p); 
23037                                   goto MATCH_label_a853; 
23038                                   
23039                                 } /*opt-block*/
23040                                 else { 
23041                                   MATCH_w_32_24 = getDword(3 + MATCH_p); 
23042                                   goto MATCH_label_a852; 
23043                                   
23044                                 } /*opt-block*/
23045                                 
23046                                 break;
23047                               case 5: 
23048                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
23049                                 goto MATCH_label_a854; 
23050                                 
23051                                 break;
23052                               default: assert(0);
23053                             } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
23054                           break;
23055                         case 1: 
23056                           MATCH_w_8_16 = getByte(2 + MATCH_p); 
23057                           if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
23058                             (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23059                                   /* index at 16 */ && 
23060                             (MATCH_w_8_16 >> 3 & 0x7) 
23061                                   /* index at 16 */ < 8)) { 
23062                             MATCH_w_32_32 = getDword(4 + MATCH_p); 
23063                             { 
23064                               unsigned Eaddr = 1 + addressToPC(MATCH_p);
23065                               unsigned i32 = MATCH_w_32_32 /* i32 at 32 */;
23066                               nextPC = 8 + MATCH_p; 
23067                               
23068                               #line 685 "machine/pentium/disassembler.m"
23069                               
23070 
23071                                       sprintf (str,  "MOV.Eb.Ivod", DIS_EADDR32, DIS_I32);
23072 
23073                               
23074 
23075                               
23076                               
23077                               
23078                             }
23079                             
23080                           } /*opt-block*/
23081                           else { 
23082                             MATCH_w_32_24 = getDword(3 + MATCH_p); 
23083                             goto MATCH_label_a852; 
23084                             
23085                           } /*opt-block*/
23086                           
23087                           break;
23088                         case 2: 
23089                           MATCH_w_8_16 = getByte(2 + MATCH_p); 
23090                           if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
23091                             (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23092                                   /* index at 16 */ && 
23093                             (MATCH_w_8_16 >> 3 & 0x7) 
23094                                   /* index at 16 */ < 8)) { 
23095                             MATCH_w_32_56 = getDword(7 + MATCH_p); 
23096                             goto MATCH_label_a853; 
23097                             
23098                           } /*opt-block*/
23099                           else { 
23100                             MATCH_w_32_48 = getDword(6 + MATCH_p); 
23101                             goto MATCH_label_a854; 
23102                             
23103                           } /*opt-block*/
23104                           
23105                           break;
23106                         case 3: 
23107                           MATCH_w_32_16 = getDword(2 + MATCH_p); 
23108                           goto MATCH_label_a851; 
23109                           
23110                           break;
23111                         default: assert(0);
23112                       } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/  
23113                   else 
23114                     goto MATCH_label_a39;  /*opt-block+*/
23115                   
23116                   break;
23117                 default: assert(0);
23118               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/  
23119           break;
23120         case 13: 
23121           if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) 
23122             
23123               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
23124                 case 0: 
23125                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
23126                   
23127                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
23128                       case 0: 
23129                         
23130                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
23131                             case 0: 
23132                               
23133                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
23134                                   case 0: case 1: case 2: case 3: case 6: 
23135                                   case 7: 
23136                                     { 
23137                                       unsigned Mem32 = 
23138                                         1 + addressToPC(MATCH_p);
23139                                       nextPC = 2 + MATCH_p; 
23140                                       
23141                                       #line 1430 "machine/pentium/disassembler.m"
23142                                       
23143 
23144                                               sprintf (str,  "FADD.R32", DIS_MEM32);
23145 
23146                                       
23147 
23148                                       
23149                                       
23150                                       
23151                                     }
23152                                     
23153                                     break;
23154                                   case 4: 
23155                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
23156                                     if ((MATCH_w_8_16 & 0x7) 
23157                                             /* base at 16 */ == 5 && 
23158                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23159                                             /* index at 16 */ && 
23160                                       (MATCH_w_8_16 >> 3 & 0x7) 
23161                                             /* index at 16 */ < 8)) 
23162                                       goto MATCH_label_a968;  /*opt-block+*/
23163                                     else 
23164                                       goto MATCH_label_a967;  /*opt-block+*/
23165                                     
23166                                     break;
23167                                   case 5: 
23168                                     goto MATCH_label_a969; break;
23169                                   default: assert(0);
23170                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
23171                               break;
23172                             case 1: 
23173                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
23174                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
23175                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23176                                       /* index at 16 */ && 
23177                                 (MATCH_w_8_16 >> 3 & 0x7) 
23178                                       /* index at 16 */ < 8)) { 
23179                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
23180                                 nextPC = 4 + MATCH_p; 
23181                                 
23182                                 #line 1430 "machine/pentium/disassembler.m"
23183                                 
23184 
23185                                         sprintf (str,  "FADD.R32", DIS_MEM32);
23186 
23187                                 
23188 
23189                                 
23190                                 
23191                                 
23192                               } /*opt-block*//*opt-block+*/
23193                               else 
23194                                 goto MATCH_label_a967;  /*opt-block+*/
23195                               
23196                               break;
23197                             case 2: 
23198                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
23199                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
23200                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23201                                       /* index at 16 */ && 
23202                                 (MATCH_w_8_16 >> 3 & 0x7) 
23203                                       /* index at 16 */ < 8)) 
23204                                 goto MATCH_label_a968;  /*opt-block+*/
23205                               else 
23206                                 goto MATCH_label_a969;  /*opt-block+*/
23207                               
23208                               break;
23209                             case 3: 
23210                               { 
23211                                 unsigned idx = 
23212                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
23213                                 nextPC = 2 + MATCH_p; 
23214                                 
23215                                 #line 1436 "machine/pentium/disassembler.m"
23216                                 
23217 
23218                                         sprintf (str,  "FADD.St.STi", DIS_IDX);
23219 
23220                                 
23221 
23222                                 
23223                                 
23224                                 
23225                               }
23226                               
23227                               break;
23228                             default: assert(0);
23229                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
23230                         break;
23231                       case 1: 
23232                         
23233                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
23234                             case 0: 
23235                               
23236                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
23237                                   case 0: case 1: case 2: case 3: case 6: 
23238                                   case 7: 
23239                                     { 
23240                                       unsigned Mem32 = 
23241                                         1 + addressToPC(MATCH_p);
23242                                       nextPC = 2 + MATCH_p; 
23243                                       
23244                                       #line 1624 "machine/pentium/disassembler.m"
23245                                       
23246 
23247                                               sprintf (str,  "FMUL.R32", DIS_MEM32);
23248 
23249                                       
23250 
23251                                       
23252                                       
23253                                       
23254                                     }
23255                                     
23256                                     break;
23257                                   case 4: 
23258                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
23259                                     if ((MATCH_w_8_16 & 0x7) 
23260                                             /* base at 16 */ == 5 && 
23261                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23262                                             /* index at 16 */ && 
23263                                       (MATCH_w_8_16 >> 3 & 0x7) 
23264                                             /* index at 16 */ < 8)) 
23265                                       goto MATCH_label_a971;  /*opt-block+*/
23266                                     else 
23267                                       goto MATCH_label_a970;  /*opt-block+*/
23268                                     
23269                                     break;
23270                                   case 5: 
23271                                     goto MATCH_label_a972; break;
23272                                   default: assert(0);
23273                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
23274                               break;
23275                             case 1: 
23276                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
23277                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
23278                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23279                                       /* index at 16 */ && 
23280                                 (MATCH_w_8_16 >> 3 & 0x7) 
23281                                       /* index at 16 */ < 8)) { 
23282                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
23283                                 nextPC = 4 + MATCH_p; 
23284                                 
23285                                 #line 1624 "machine/pentium/disassembler.m"
23286                                 
23287 
23288                                         sprintf (str,  "FMUL.R32", DIS_MEM32);
23289 
23290                                 
23291 
23292                                 
23293                                 
23294                                 
23295                               } /*opt-block*//*opt-block+*/
23296                               else 
23297                                 goto MATCH_label_a970;  /*opt-block+*/
23298                               
23299                               break;
23300                             case 2: 
23301                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
23302                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
23303                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23304                                       /* index at 16 */ && 
23305                                 (MATCH_w_8_16 >> 3 & 0x7) 
23306                                       /* index at 16 */ < 8)) 
23307                                 goto MATCH_label_a971;  /*opt-block+*/
23308                               else 
23309                                 goto MATCH_label_a972;  /*opt-block+*/
23310                               
23311                               break;
23312                             case 3: 
23313                               { 
23314                                 unsigned idx = 
23315                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
23316                                 nextPC = 2 + MATCH_p; 
23317                                 
23318                                 #line 1630 "machine/pentium/disassembler.m"
23319                                 
23320 
23321                                         sprintf (str,  "FMUL.ST.STi", DIS_IDX);
23322 
23323                                 
23324 
23325                                 
23326                                 
23327                                 
23328                               }
23329                               
23330                               break;
23331                             default: assert(0);
23332                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
23333                         break;
23334                       case 2: 
23335                         
23336                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
23337                             case 0: 
23338                               
23339                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
23340                                   case 0: case 1: case 2: case 3: case 6: 
23341                                   case 7: 
23342                                     { 
23343                                       unsigned Mem32 = 
23344                                         1 + addressToPC(MATCH_p);
23345                                       nextPC = 2 + MATCH_p; 
23346                                       
23347                                       #line 1463 "machine/pentium/disassembler.m"
23348                                       
23349 
23350                                               sprintf (str,  "FCOM.R32", DIS_MEM32);
23351 
23352                                       
23353 
23354                                       
23355                                       
23356                                       
23357                                     }
23358                                     
23359                                     break;
23360                                   case 4: 
23361                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
23362                                     if ((MATCH_w_8_16 & 0x7) 
23363                                             /* base at 16 */ == 5 && 
23364                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23365                                             /* index at 16 */ && 
23366                                       (MATCH_w_8_16 >> 3 & 0x7) 
23367                                             /* index at 16 */ < 8)) 
23368                                       goto MATCH_label_a974;  /*opt-block+*/
23369                                     else 
23370                                       goto MATCH_label_a973;  /*opt-block+*/
23371                                     
23372                                     break;
23373                                   case 5: 
23374                                     goto MATCH_label_a975; break;
23375                                   default: assert(0);
23376                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
23377                               break;
23378                             case 1: 
23379                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
23380                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
23381                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23382                                       /* index at 16 */ && 
23383                                 (MATCH_w_8_16 >> 3 & 0x7) 
23384                                       /* index at 16 */ < 8)) { 
23385                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
23386                                 nextPC = 4 + MATCH_p; 
23387                                 
23388                                 #line 1463 "machine/pentium/disassembler.m"
23389                                 
23390 
23391                                         sprintf (str,  "FCOM.R32", DIS_MEM32);
23392 
23393                                 
23394 
23395                                 
23396                                 
23397                                 
23398                               } /*opt-block*//*opt-block+*/
23399                               else 
23400                                 goto MATCH_label_a973;  /*opt-block+*/
23401                               
23402                               break;
23403                             case 2: 
23404                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
23405                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
23406                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23407                                       /* index at 16 */ && 
23408                                 (MATCH_w_8_16 >> 3 & 0x7) 
23409                                       /* index at 16 */ < 8)) 
23410                                 goto MATCH_label_a974;  /*opt-block+*/
23411                               else 
23412                                 goto MATCH_label_a975;  /*opt-block+*/
23413                               
23414                               break;
23415                             case 3: 
23416                               { 
23417                                 unsigned idx = 
23418                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
23419                                 nextPC = 2 + MATCH_p; 
23420                                 
23421                                 #line 1481 "machine/pentium/disassembler.m"
23422                                 
23423 
23424                                         sprintf (str,  "FCOM.ST.STi", DIS_IDX);
23425 
23426                                 
23427 
23428                                 
23429                                 
23430                                 
23431                               }
23432                               
23433                               break;
23434                             default: assert(0);
23435                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
23436                         break;
23437                       case 3: 
23438                         
23439                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
23440                             case 0: 
23441                               
23442                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
23443                                   case 0: case 1: case 2: case 3: case 6: 
23444                                   case 7: 
23445                                     { 
23446                                       unsigned Mem32 = 
23447                                         1 + addressToPC(MATCH_p);
23448                                       nextPC = 2 + MATCH_p; 
23449                                       
23450                                       #line 1475 "machine/pentium/disassembler.m"
23451                                       
23452 
23453                                               sprintf (str,  "FCOMP.R32", DIS_MEM32);
23454 
23455                                       
23456 
23457                                       
23458                                       
23459                                       
23460                                     }
23461                                     
23462                                     break;
23463                                   case 4: 
23464                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
23465                                     if ((MATCH_w_8_16 & 0x7) 
23466                                             /* base at 16 */ == 5 && 
23467                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23468                                             /* index at 16 */ && 
23469                                       (MATCH_w_8_16 >> 3 & 0x7) 
23470                                             /* index at 16 */ < 8)) 
23471                                       goto MATCH_label_a977;  /*opt-block+*/
23472                                     else 
23473                                       goto MATCH_label_a976;  /*opt-block+*/
23474                                     
23475                                     break;
23476                                   case 5: 
23477                                     goto MATCH_label_a978; break;
23478                                   default: assert(0);
23479                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
23480                               break;
23481                             case 1: 
23482                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
23483                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
23484                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23485                                       /* index at 16 */ && 
23486                                 (MATCH_w_8_16 >> 3 & 0x7) 
23487                                       /* index at 16 */ < 8)) { 
23488                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
23489                                 nextPC = 4 + MATCH_p; 
23490                                 
23491                                 #line 1475 "machine/pentium/disassembler.m"
23492                                 
23493 
23494                                         sprintf (str,  "FCOMP.R32", DIS_MEM32);
23495 
23496                                 
23497 
23498                                 
23499                                 
23500                                 
23501                               } /*opt-block*//*opt-block+*/
23502                               else 
23503                                 goto MATCH_label_a976;  /*opt-block+*/
23504                               
23505                               break;
23506                             case 2: 
23507                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
23508                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
23509                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23510                                       /* index at 16 */ && 
23511                                 (MATCH_w_8_16 >> 3 & 0x7) 
23512                                       /* index at 16 */ < 8)) 
23513                                 goto MATCH_label_a977;  /*opt-block+*/
23514                               else 
23515                                 goto MATCH_label_a978;  /*opt-block+*/
23516                               
23517                               break;
23518                             case 3: 
23519                               { 
23520                                 unsigned idx = 
23521                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
23522                                 nextPC = 2 + MATCH_p; 
23523                                 
23524                                 #line 1484 "machine/pentium/disassembler.m"
23525                                 
23526 
23527                                         sprintf (str,  "FCOMP.ST.STi", DIS_IDX);
23528 
23529                                 
23530 
23531                                 
23532                                 
23533                                 
23534                               }
23535                               
23536                               break;
23537                             default: assert(0);
23538                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
23539                         break;
23540                       case 4: 
23541                         
23542                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
23543                             case 0: 
23544                               
23545                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
23546                                   case 0: case 1: case 2: case 3: case 6: 
23547                                   case 7: 
23548                                     { 
23549                                       unsigned Mem32 = 
23550                                         1 + addressToPC(MATCH_p);
23551                                       nextPC = 2 + MATCH_p; 
23552                                       
23553                                       #line 1714 "machine/pentium/disassembler.m"
23554                                       
23555 
23556                                               sprintf (str,  "FSUB.R32", DIS_MEM32);
23557 
23558                                       
23559 
23560                                       
23561                                       
23562                                       
23563                                     }
23564                                     
23565                                     break;
23566                                   case 4: 
23567                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
23568                                     if ((MATCH_w_8_16 & 0x7) 
23569                                             /* base at 16 */ == 5 && 
23570                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23571                                             /* index at 16 */ && 
23572                                       (MATCH_w_8_16 >> 3 & 0x7) 
23573                                             /* index at 16 */ < 8)) 
23574                                       goto MATCH_label_a980;  /*opt-block+*/
23575                                     else 
23576                                       goto MATCH_label_a979;  /*opt-block+*/
23577                                     
23578                                     break;
23579                                   case 5: 
23580                                     goto MATCH_label_a981; break;
23581                                   default: assert(0);
23582                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
23583                               break;
23584                             case 1: 
23585                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
23586                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
23587                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23588                                       /* index at 16 */ && 
23589                                 (MATCH_w_8_16 >> 3 & 0x7) 
23590                                       /* index at 16 */ < 8)) { 
23591                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
23592                                 nextPC = 4 + MATCH_p; 
23593                                 
23594                                 #line 1714 "machine/pentium/disassembler.m"
23595                                 
23596 
23597                                         sprintf (str,  "FSUB.R32", DIS_MEM32);
23598 
23599                                 
23600 
23601                                 
23602                                 
23603                                 
23604                               } /*opt-block*//*opt-block+*/
23605                               else 
23606                                 goto MATCH_label_a979;  /*opt-block+*/
23607                               
23608                               break;
23609                             case 2: 
23610                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
23611                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
23612                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23613                                       /* index at 16 */ && 
23614                                 (MATCH_w_8_16 >> 3 & 0x7) 
23615                                       /* index at 16 */ < 8)) 
23616                                 goto MATCH_label_a980;  /*opt-block+*/
23617                               else 
23618                                 goto MATCH_label_a981;  /*opt-block+*/
23619                               
23620                               break;
23621                             case 3: 
23622                               { 
23623                                 unsigned idx = 
23624                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
23625                                 nextPC = 2 + MATCH_p; 
23626                                 
23627                                 #line 1720 "machine/pentium/disassembler.m"
23628                                 
23629 
23630                                         sprintf (str,  "FSUB.ST.STi", DIS_IDX);
23631 
23632                                 
23633 
23634                                 
23635                                 
23636                                 
23637                               }
23638                               
23639                               break;
23640                             default: assert(0);
23641                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
23642                         break;
23643                       case 5: 
23644                         
23645                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
23646                             case 0: 
23647                               
23648                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
23649                                   case 0: case 1: case 2: case 3: case 6: 
23650                                   case 7: 
23651                                     { 
23652                                       unsigned Mem32 = 
23653                                         1 + addressToPC(MATCH_p);
23654                                       nextPC = 2 + MATCH_p; 
23655                                       
23656                                       #line 1735 "machine/pentium/disassembler.m"
23657                                       
23658 
23659                                               sprintf (str,  "FSUBR.R32", DIS_MEM32);
23660 
23661                                       
23662 
23663                                       
23664                                       
23665                                       
23666                                     }
23667                                     
23668                                     break;
23669                                   case 4: 
23670                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
23671                                     if ((MATCH_w_8_16 & 0x7) 
23672                                             /* base at 16 */ == 5 && 
23673                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23674                                             /* index at 16 */ && 
23675                                       (MATCH_w_8_16 >> 3 & 0x7) 
23676                                             /* index at 16 */ < 8)) 
23677                                       goto MATCH_label_a983;  /*opt-block+*/
23678                                     else 
23679                                       goto MATCH_label_a982;  /*opt-block+*/
23680                                     
23681                                     break;
23682                                   case 5: 
23683                                     goto MATCH_label_a984; break;
23684                                   default: assert(0);
23685                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
23686                               break;
23687                             case 1: 
23688                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
23689                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
23690                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23691                                       /* index at 16 */ && 
23692                                 (MATCH_w_8_16 >> 3 & 0x7) 
23693                                       /* index at 16 */ < 8)) { 
23694                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
23695                                 nextPC = 4 + MATCH_p; 
23696                                 
23697                                 #line 1735 "machine/pentium/disassembler.m"
23698                                 
23699 
23700                                         sprintf (str,  "FSUBR.R32", DIS_MEM32);
23701 
23702                                 
23703 
23704                                 
23705                                 
23706                                 
23707                               } /*opt-block*//*opt-block+*/
23708                               else 
23709                                 goto MATCH_label_a982;  /*opt-block+*/
23710                               
23711                               break;
23712                             case 2: 
23713                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
23714                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
23715                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23716                                       /* index at 16 */ && 
23717                                 (MATCH_w_8_16 >> 3 & 0x7) 
23718                                       /* index at 16 */ < 8)) 
23719                                 goto MATCH_label_a983;  /*opt-block+*/
23720                               else 
23721                                 goto MATCH_label_a984;  /*opt-block+*/
23722                               
23723                               break;
23724                             case 3: 
23725                               { 
23726                                 unsigned idx = 
23727                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
23728                                 nextPC = 2 + MATCH_p; 
23729                                 
23730                                 #line 1741 "machine/pentium/disassembler.m"
23731                                 
23732 
23733                                         sprintf (str,  "FSUBR.ST.STi", DIS_IDX);
23734 
23735                                 
23736 
23737                                 
23738                                 
23739                                 
23740                               }
23741                               
23742                               break;
23743                             default: assert(0);
23744                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
23745                         break;
23746                       case 6: 
23747                         
23748                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
23749                             case 0: 
23750                               
23751                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
23752                                   case 0: case 1: case 2: case 3: case 6: 
23753                                   case 7: 
23754                                     { 
23755                                       unsigned Mem32 = 
23756                                         1 + addressToPC(MATCH_p);
23757                                       nextPC = 2 + MATCH_p; 
23758                                       
23759                                       #line 1508 "machine/pentium/disassembler.m"
23760                                       
23761 
23762                                               sprintf (str,  "FDIV.R32", DIS_MEM32);
23763 
23764                                       
23765 
23766                                       
23767                                       
23768                                       
23769                                     }
23770                                     
23771                                     break;
23772                                   case 4: 
23773                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
23774                                     if ((MATCH_w_8_16 & 0x7) 
23775                                             /* base at 16 */ == 5 && 
23776                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23777                                             /* index at 16 */ && 
23778                                       (MATCH_w_8_16 >> 3 & 0x7) 
23779                                             /* index at 16 */ < 8)) 
23780                                       goto MATCH_label_a986;  /*opt-block+*/
23781                                     else 
23782                                       goto MATCH_label_a985;  /*opt-block+*/
23783                                     
23784                                     break;
23785                                   case 5: 
23786                                     goto MATCH_label_a987; break;
23787                                   default: assert(0);
23788                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
23789                               break;
23790                             case 1: 
23791                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
23792                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
23793                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23794                                       /* index at 16 */ && 
23795                                 (MATCH_w_8_16 >> 3 & 0x7) 
23796                                       /* index at 16 */ < 8)) { 
23797                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
23798                                 nextPC = 4 + MATCH_p; 
23799                                 
23800                                 #line 1508 "machine/pentium/disassembler.m"
23801                                 
23802 
23803                                         sprintf (str,  "FDIV.R32", DIS_MEM32);
23804 
23805                                 
23806 
23807                                 
23808                                 
23809                                 
23810                               } /*opt-block*//*opt-block+*/
23811                               else 
23812                                 goto MATCH_label_a985;  /*opt-block+*/
23813                               
23814                               break;
23815                             case 2: 
23816                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
23817                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
23818                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23819                                       /* index at 16 */ && 
23820                                 (MATCH_w_8_16 >> 3 & 0x7) 
23821                                       /* index at 16 */ < 8)) 
23822                                 goto MATCH_label_a986;  /*opt-block+*/
23823                               else 
23824                                 goto MATCH_label_a987;  /*opt-block+*/
23825                               
23826                               break;
23827                             case 3: 
23828                               { 
23829                                 unsigned idx = 
23830                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
23831                                 nextPC = 2 + MATCH_p; 
23832                                 
23833                                 #line 1514 "machine/pentium/disassembler.m"
23834                                 
23835 
23836                                         sprintf (str,  "FDIV.ST.STi", DIS_IDX);
23837 
23838                                 
23839 
23840                                 
23841                                 
23842                                 
23843                               }
23844                               
23845                               break;
23846                             default: assert(0);
23847                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
23848                         break;
23849                       case 7: 
23850                         
23851                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
23852                             case 0: 
23853                               
23854                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
23855                                   case 0: case 1: case 2: case 3: case 6: 
23856                                   case 7: 
23857                                     { 
23858                                       unsigned Mem32 = 
23859                                         1 + addressToPC(MATCH_p);
23860                                       nextPC = 2 + MATCH_p; 
23861                                       
23862                                       #line 1529 "machine/pentium/disassembler.m"
23863                                       
23864 
23865                                               sprintf (str,  "FDIVR.R32", DIS_MEM32);
23866 
23867                                       
23868 
23869                                       
23870                                       
23871                                       
23872                                     }
23873                                     
23874                                     break;
23875                                   case 4: 
23876                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
23877                                     if ((MATCH_w_8_16 & 0x7) 
23878                                             /* base at 16 */ == 5 && 
23879                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23880                                             /* index at 16 */ && 
23881                                       (MATCH_w_8_16 >> 3 & 0x7) 
23882                                             /* index at 16 */ < 8)) 
23883                                       goto MATCH_label_a989;  /*opt-block+*/
23884                                     else 
23885                                       goto MATCH_label_a988;  /*opt-block+*/
23886                                     
23887                                     break;
23888                                   case 5: 
23889                                     goto MATCH_label_a990; break;
23890                                   default: assert(0);
23891                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
23892                               break;
23893                             case 1: 
23894                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
23895                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
23896                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23897                                       /* index at 16 */ && 
23898                                 (MATCH_w_8_16 >> 3 & 0x7) 
23899                                       /* index at 16 */ < 8)) { 
23900                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
23901                                 nextPC = 4 + MATCH_p; 
23902                                 
23903                                 #line 1529 "machine/pentium/disassembler.m"
23904                                 
23905 
23906                                         sprintf (str,  "FDIVR.R32", DIS_MEM32);
23907 
23908                                 
23909 
23910                                 
23911                                 
23912                                 
23913                               } /*opt-block*//*opt-block+*/
23914                               else 
23915                                 goto MATCH_label_a988;  /*opt-block+*/
23916                               
23917                               break;
23918                             case 2: 
23919                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
23920                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
23921                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23922                                       /* index at 16 */ && 
23923                                 (MATCH_w_8_16 >> 3 & 0x7) 
23924                                       /* index at 16 */ < 8)) 
23925                                 goto MATCH_label_a989;  /*opt-block+*/
23926                               else 
23927                                 goto MATCH_label_a990;  /*opt-block+*/
23928                               
23929                               break;
23930                             case 3: 
23931                               { 
23932                                 unsigned idx = 
23933                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
23934                                 nextPC = 2 + MATCH_p; 
23935                                 
23936                                 #line 1535 "machine/pentium/disassembler.m"
23937                                 
23938 
23939                                         sprintf (str,  "FDIVR.ST.STi", DIS_IDX);
23940 
23941                                 
23942 
23943                                 
23944                                 
23945                                 
23946                               }
23947                               
23948                               break;
23949                             default: assert(0);
23950                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
23951                         break;
23952                       default: assert(0);
23953                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
23954                   
23955                   break;
23956                 case 1: 
23957                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
23958                   
23959                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
23960                       case 0: 
23961                         
23962                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
23963                             case 0: 
23964                               
23965                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
23966                                   case 0: case 1: case 2: case 3: case 6: 
23967                                   case 7: 
23968                                     { 
23969                                       unsigned Mem32 = 
23970                                         1 + addressToPC(MATCH_p);
23971                                       nextPC = 2 + MATCH_p; 
23972                                       
23973                                       #line 1580 "machine/pentium/disassembler.m"
23974                                       
23975 
23976                                               sprintf (str,  "FLD.lsR32", DIS_MEM32);
23977 
23978                                       
23979 
23980                                       
23981                                       
23982                                       
23983                                     }
23984                                     
23985                                     break;
23986                                   case 4: 
23987                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
23988                                     if ((MATCH_w_8_16 & 0x7) 
23989                                             /* base at 16 */ == 5 && 
23990                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
23991                                             /* index at 16 */ && 
23992                                       (MATCH_w_8_16 >> 3 & 0x7) 
23993                                             /* index at 16 */ < 8)) 
23994                                       goto MATCH_label_a992;  /*opt-block+*/
23995                                     else 
23996                                       goto MATCH_label_a991;  /*opt-block+*/
23997                                     
23998                                     break;
23999                                   case 5: 
24000                                     goto MATCH_label_a993; break;
24001                                   default: assert(0);
24002                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
24003                               break;
24004                             case 1: 
24005                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
24006                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
24007                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24008                                       /* index at 16 */ && 
24009                                 (MATCH_w_8_16 >> 3 & 0x7) 
24010                                       /* index at 16 */ < 8)) { 
24011                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
24012                                 nextPC = 4 + MATCH_p; 
24013                                 
24014                                 #line 1580 "machine/pentium/disassembler.m"
24015                                 
24016 
24017                                         sprintf (str,  "FLD.lsR32", DIS_MEM32);
24018 
24019                                 
24020 
24021                                 
24022                                 
24023                                 
24024                               } /*opt-block*//*opt-block+*/
24025                               else 
24026                                 goto MATCH_label_a991;  /*opt-block+*/
24027                               
24028                               break;
24029                             case 2: 
24030                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
24031                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
24032                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24033                                       /* index at 16 */ && 
24034                                 (MATCH_w_8_16 >> 3 & 0x7) 
24035                                       /* index at 16 */ < 8)) 
24036                                 goto MATCH_label_a992;  /*opt-block+*/
24037                               else 
24038                                 goto MATCH_label_a993;  /*opt-block+*/
24039                               
24040                               break;
24041                             case 3: 
24042                               { 
24043                                 unsigned idx = 
24044                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
24045                                 nextPC = 2 + MATCH_p; 
24046                                 
24047                                 #line 1594 "machine/pentium/disassembler.m"
24048                                 
24049 
24050                                         sprintf (str,  "FLD.STi", DIS_IDXP1);
24051 
24052                                 
24053 
24054                                 
24055                                 
24056                                 
24057                               }
24058                               
24059                               break;
24060                             default: assert(0);
24061                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
24062                         break;
24063                       case 1: 
24064                         if ((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */ == 3) { 
24065                           unsigned idx = (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
24066                           nextPC = 2 + MATCH_p; 
24067                           
24068                           #line 1777 "machine/pentium/disassembler.m"
24069                           
24070 
24071                                   sprintf (str,  "FXCH", DIS_IDX);
24072 
24073                           
24074 
24075                           
24076                           
24077                           
24078                         } /*opt-block*//*opt-block+*/
24079                         else 
24080                           goto MATCH_label_a39;  /*opt-block+*/
24081                         
24082                         break;
24083                       case 2: 
24084                         
24085                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
24086                             case 0: 
24087                               
24088                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
24089                                   case 0: case 1: case 2: case 3: case 6: 
24090                                   case 7: 
24091                                     { 
24092                                       unsigned Mem32 = 
24093                                         1 + addressToPC(MATCH_p);
24094                                       nextPC = 2 + MATCH_p; 
24095                                       
24096                                       #line 1681 "machine/pentium/disassembler.m"
24097                                       
24098 
24099                                               sprintf (str,  "FST.lsR32", DIS_MEM32);
24100 
24101                                       
24102 
24103                                       
24104                                       
24105                                       
24106                                     }
24107                                     
24108                                     break;
24109                                   case 4: 
24110                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
24111                                     if ((MATCH_w_8_16 & 0x7) 
24112                                             /* base at 16 */ == 5 && 
24113                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24114                                             /* index at 16 */ && 
24115                                       (MATCH_w_8_16 >> 3 & 0x7) 
24116                                             /* index at 16 */ < 8)) 
24117                                       goto MATCH_label_a995;  /*opt-block+*/
24118                                     else 
24119                                       goto MATCH_label_a994;  /*opt-block+*/
24120                                     
24121                                     break;
24122                                   case 5: 
24123                                     goto MATCH_label_a996; break;
24124                                   default: assert(0);
24125                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
24126                               break;
24127                             case 1: 
24128                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
24129                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
24130                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24131                                       /* index at 16 */ && 
24132                                 (MATCH_w_8_16 >> 3 & 0x7) 
24133                                       /* index at 16 */ < 8)) { 
24134                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
24135                                 nextPC = 4 + MATCH_p; 
24136                                 
24137                                 #line 1681 "machine/pentium/disassembler.m"
24138                                 
24139 
24140                                         sprintf (str,  "FST.lsR32", DIS_MEM32);
24141 
24142                                 
24143 
24144                                 
24145                                 
24146                                 
24147                               } /*opt-block*//*opt-block+*/
24148                               else 
24149                                 goto MATCH_label_a994;  /*opt-block+*/
24150                               
24151                               break;
24152                             case 2: 
24153                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
24154                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
24155                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24156                                       /* index at 16 */ && 
24157                                 (MATCH_w_8_16 >> 3 & 0x7) 
24158                                       /* index at 16 */ < 8)) 
24159                                 goto MATCH_label_a995;  /*opt-block+*/
24160                               else 
24161                                 goto MATCH_label_a996;  /*opt-block+*/
24162                               
24163                               break;
24164                             case 3: 
24165                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 0) { 
24166                                 nextPC = 2 + MATCH_p; 
24167                                 
24168                                 #line 1645 "machine/pentium/disassembler.m"
24169                                 
24170 
24171                                         sprintf (str,  "FNOP");
24172 
24173                                 
24174 
24175                                 
24176                                 
24177                                 
24178                               } /*opt-block*//*opt-block+*/
24179                               else 
24180                                 goto MATCH_label_a39;  /*opt-block+*/
24181                               
24182                               break;
24183                             default: assert(0);
24184                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
24185                         break;
24186                       case 3: 
24187                         
24188                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
24189                             case 0: 
24190                               
24191                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
24192                                   case 0: case 1: case 2: case 3: case 6: 
24193                                   case 7: 
24194                                     { 
24195                                       unsigned Mem32 = 
24196                                         1 + addressToPC(MATCH_p);
24197                                       nextPC = 2 + MATCH_p; 
24198                                       
24199                                       #line 1687 "machine/pentium/disassembler.m"
24200                                       
24201 
24202                                               sprintf (str,  "FSTP.lsR32", DIS_MEM32);
24203 
24204                                       
24205 
24206                                       
24207                                       
24208                                       
24209                                     }
24210                                     
24211                                     break;
24212                                   case 4: 
24213                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
24214                                     if ((MATCH_w_8_16 & 0x7) 
24215                                             /* base at 16 */ == 5 && 
24216                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24217                                             /* index at 16 */ && 
24218                                       (MATCH_w_8_16 >> 3 & 0x7) 
24219                                             /* index at 16 */ < 8)) 
24220                                       goto MATCH_label_a998;  /*opt-block+*/
24221                                     else 
24222                                       goto MATCH_label_a997;  /*opt-block+*/
24223                                     
24224                                     break;
24225                                   case 5: 
24226                                     goto MATCH_label_a999; break;
24227                                   default: assert(0);
24228                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
24229                               break;
24230                             case 1: 
24231                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
24232                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
24233                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24234                                       /* index at 16 */ && 
24235                                 (MATCH_w_8_16 >> 3 & 0x7) 
24236                                       /* index at 16 */ < 8)) { 
24237                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
24238                                 nextPC = 4 + MATCH_p; 
24239                                 
24240                                 #line 1687 "machine/pentium/disassembler.m"
24241                                 
24242 
24243                                         sprintf (str,  "FSTP.lsR32", DIS_MEM32);
24244 
24245                                 
24246 
24247                                 
24248                                 
24249                                 
24250                               } /*opt-block*//*opt-block+*/
24251                               else 
24252                                 goto MATCH_label_a997;  /*opt-block+*/
24253                               
24254                               break;
24255                             case 2: 
24256                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
24257                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
24258                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24259                                       /* index at 16 */ && 
24260                                 (MATCH_w_8_16 >> 3 & 0x7) 
24261                                       /* index at 16 */ < 8)) 
24262                                 goto MATCH_label_a998;  /*opt-block+*/
24263                               else 
24264                                 goto MATCH_label_a999;  /*opt-block+*/
24265                               
24266                               break;
24267                             case 3: 
24268                               goto MATCH_label_a39; break;
24269                             default: assert(0);
24270                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
24271                         break;
24272                       case 4: 
24273                         
24274                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
24275                             case 0: 
24276                               
24277                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
24278                                   case 0: case 1: case 2: case 3: case 6: 
24279                                   case 7: 
24280                                     { 
24281                                       unsigned Mem = 1 + addressToPC(MATCH_p);
24282                                       nextPC = 2 + MATCH_p; 
24283                                       
24284                                       #line 1621 "machine/pentium/disassembler.m"
24285                                       
24286 
24287                                               sprintf (str,  "FLDENV", DIS_MEM);
24288 
24289                                       
24290 
24291                                       
24292                                       
24293                                       
24294                                     }
24295                                     
24296                                     break;
24297                                   case 4: 
24298                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
24299                                     if ((MATCH_w_8_16 & 0x7) 
24300                                             /* base at 16 */ == 5 && 
24301                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24302                                             /* index at 16 */ && 
24303                                       (MATCH_w_8_16 >> 3 & 0x7) 
24304                                             /* index at 16 */ < 8)) 
24305                                       goto MATCH_label_a1001;  /*opt-block+*/
24306                                     else 
24307                                       goto MATCH_label_a1000;  /*opt-block+*/
24308                                     
24309                                     break;
24310                                   case 5: 
24311                                     goto MATCH_label_a1002; break;
24312                                   default: assert(0);
24313                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
24314                               break;
24315                             case 1: 
24316                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
24317                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
24318                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24319                                       /* index at 16 */ && 
24320                                 (MATCH_w_8_16 >> 3 & 0x7) 
24321                                       /* index at 16 */ < 8)) { 
24322                                 unsigned Mem = 1 + addressToPC(MATCH_p);
24323                                 nextPC = 4 + MATCH_p; 
24324                                 
24325                                 #line 1621 "machine/pentium/disassembler.m"
24326                                 
24327 
24328                                         sprintf (str,  "FLDENV", DIS_MEM);
24329 
24330                                 
24331 
24332                                 
24333                                 
24334                                 
24335                               } /*opt-block*//*opt-block+*/
24336                               else 
24337                                 goto MATCH_label_a1000;  /*opt-block+*/
24338                               
24339                               break;
24340                             case 2: 
24341                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
24342                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
24343                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24344                                       /* index at 16 */ && 
24345                                 (MATCH_w_8_16 >> 3 & 0x7) 
24346                                       /* index at 16 */ < 8)) 
24347                                 goto MATCH_label_a1001;  /*opt-block+*/
24348                               else 
24349                                 goto MATCH_label_a1002;  /*opt-block+*/
24350                               
24351                               break;
24352                             case 3: 
24353                               
24354                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
24355                                   case 0: 
24356                                     nextPC = 2 + MATCH_p; 
24357                                     
24358                                     #line 1457 "machine/pentium/disassembler.m"
24359                                     
24360 
24361                                             sprintf (str,  "FCHS");
24362 
24363                                     
24364 
24365                                     
24366                                     
24367                                     
24368                                     
24369                                     break;
24370                                   case 1: 
24371                                     nextPC = 2 + MATCH_p; 
24372                                     
24373                                     #line 1427 "machine/pentium/disassembler.m"
24374                                     
24375 
24376                                             sprintf (str,  "FABS");
24377 
24378                                     
24379 
24380                                     
24381                                     
24382                                     
24383                                     
24384                                     break;
24385                                   case 2: case 3: case 6: case 7: 
24386                                     goto MATCH_label_a39; break;
24387                                   case 4: 
24388                                     nextPC = 2 + MATCH_p; 
24389                                     
24390                                     #line 1756 "machine/pentium/disassembler.m"
24391                                     
24392 
24393                                             sprintf (str,  "FTST");
24394 
24395                                     
24396 
24397                                     
24398                                     
24399                                     
24400                                     
24401                                     break;
24402                                   case 5: 
24403                                     nextPC = 2 + MATCH_p; 
24404                                     
24405                                     #line 1774 "machine/pentium/disassembler.m"
24406                                     
24407 
24408                                             sprintf (str,  "FXAM");
24409 
24410                                     
24411 
24412                                     
24413                                     
24414                                     
24415                                     
24416                                     break;
24417                                   default: assert(0);
24418                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
24419                               break;
24420                             default: assert(0);
24421                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
24422                         break;
24423                       case 5: 
24424                         
24425                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
24426                             case 0: 
24427                               
24428                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
24429                                   case 0: case 1: case 2: case 3: case 6: 
24430                                   case 7: 
24431                                     { 
24432                                       unsigned Mem16 = 
24433                                         1 + addressToPC(MATCH_p);
24434                                       nextPC = 2 + MATCH_p; 
24435                                       
24436                                       #line 1618 "machine/pentium/disassembler.m"
24437                                       
24438 
24439                                               sprintf (str,  "FLDCW", DIS_MEM16);
24440 
24441                                       
24442 
24443                                       
24444                                       
24445                                       
24446                                     }
24447                                     
24448                                     break;
24449                                   case 4: 
24450                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
24451                                     if ((MATCH_w_8_16 & 0x7) 
24452                                             /* base at 16 */ == 5 && 
24453                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24454                                             /* index at 16 */ && 
24455                                       (MATCH_w_8_16 >> 3 & 0x7) 
24456                                             /* index at 16 */ < 8)) 
24457                                       goto MATCH_label_a1004;  /*opt-block+*/
24458                                     else 
24459                                       goto MATCH_label_a1003;  /*opt-block+*/
24460                                     
24461                                     break;
24462                                   case 5: 
24463                                     goto MATCH_label_a1005; break;
24464                                   default: assert(0);
24465                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
24466                               break;
24467                             case 1: 
24468                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
24469                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
24470                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24471                                       /* index at 16 */ && 
24472                                 (MATCH_w_8_16 >> 3 & 0x7) 
24473                                       /* index at 16 */ < 8)) { 
24474                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
24475                                 nextPC = 4 + MATCH_p; 
24476                                 
24477                                 #line 1618 "machine/pentium/disassembler.m"
24478                                 
24479 
24480                                         sprintf (str,  "FLDCW", DIS_MEM16);
24481 
24482                                 
24483 
24484                                 
24485                                 
24486                                 
24487                               } /*opt-block*//*opt-block+*/
24488                               else 
24489                                 goto MATCH_label_a1003;  /*opt-block+*/
24490                               
24491                               break;
24492                             case 2: 
24493                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
24494                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
24495                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24496                                       /* index at 16 */ && 
24497                                 (MATCH_w_8_16 >> 3 & 0x7) 
24498                                       /* index at 16 */ < 8)) 
24499                                 goto MATCH_label_a1004;  /*opt-block+*/
24500                               else 
24501                                 goto MATCH_label_a1005;  /*opt-block+*/
24502                               
24503                               break;
24504                             case 3: 
24505                               
24506                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
24507                                   case 0: 
24508                                     nextPC = 2 + MATCH_p; 
24509                                     
24510                                     #line 1597 "machine/pentium/disassembler.m"
24511                                     
24512 
24513                                             sprintf (str,  "FLD1");
24514 
24515                                     
24516 
24517                                     
24518                                     
24519                                     
24520                                     
24521                                     break;
24522                                   case 1: 
24523                                     nextPC = 2 + MATCH_p; 
24524                                     
24525                                     #line 1600 "machine/pentium/disassembler.m"
24526                                     
24527 
24528                                             sprintf (str,  "FLDL2T");
24529 
24530                                     
24531 
24532                                     
24533                                     
24534                                     
24535                                     
24536                                     break;
24537                                   case 2: 
24538                                     nextPC = 2 + MATCH_p; 
24539                                     
24540                                     #line 1603 "machine/pentium/disassembler.m"
24541                                     
24542 
24543                                             sprintf (str,  "FLDL2E");
24544 
24545                                     
24546 
24547                                     
24548                                     
24549                                     
24550                                     
24551                                     break;
24552                                   case 3: 
24553                                     nextPC = 2 + MATCH_p; 
24554                                     
24555                                     #line 1606 "machine/pentium/disassembler.m"
24556                                     
24557 
24558                                             sprintf (str,  "FLDPI");
24559 
24560                                     
24561 
24562                                     
24563                                     
24564                                     
24565                                     
24566                                     break;
24567                                   case 4: 
24568                                     nextPC = 2 + MATCH_p; 
24569                                     
24570                                     #line 1609 "machine/pentium/disassembler.m"
24571                                     
24572 
24573                                             sprintf (str,  "FLDLG2");
24574 
24575                                     
24576 
24577                                     
24578                                     
24579                                     
24580                                     
24581                                     break;
24582                                   case 5: 
24583                                     nextPC = 2 + MATCH_p; 
24584                                     
24585                                     #line 1612 "machine/pentium/disassembler.m"
24586                                     
24587 
24588                                             sprintf (str,  "FLDLN2");
24589 
24590                                     
24591 
24592                                     
24593                                     
24594                                     
24595                                     
24596                                     break;
24597                                   case 6: 
24598                                     nextPC = 2 + MATCH_p; 
24599                                     
24600                                     #line 1615 "machine/pentium/disassembler.m"
24601                                     
24602 
24603                                             sprintf (str,  "FLDZ");
24604 
24605                                     
24606 
24607                                     
24608                                     
24609                                     
24610                                     
24611                                     break;
24612                                   case 7: 
24613                                     goto MATCH_label_a39; break;
24614                                   default: assert(0);
24615                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
24616                               break;
24617                             default: assert(0);
24618                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
24619                         break;
24620                       case 6: 
24621                         
24622                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
24623                             case 0: 
24624                               
24625                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
24626                                   case 0: case 1: case 2: case 3: case 6: 
24627                                   case 7: 
24628                                     { 
24629                                       unsigned Mem = 1 + addressToPC(MATCH_p);
24630                                       nextPC = 2 + MATCH_p; 
24631                                       
24632                                       #line 1705 "machine/pentium/disassembler.m"
24633                                       
24634 
24635                                               sprintf (str,  "FSTENV", DIS_MEM);
24636 
24637                                       
24638 
24639                                       
24640                                       
24641                                       
24642                                     }
24643                                     
24644                                     break;
24645                                   case 4: 
24646                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
24647                                     if ((MATCH_w_8_16 & 0x7) 
24648                                             /* base at 16 */ == 5 && 
24649                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24650                                             /* index at 16 */ && 
24651                                       (MATCH_w_8_16 >> 3 & 0x7) 
24652                                             /* index at 16 */ < 8)) 
24653                                       goto MATCH_label_a1007;  /*opt-block+*/
24654                                     else 
24655                                       goto MATCH_label_a1006;  /*opt-block+*/
24656                                     
24657                                     break;
24658                                   case 5: 
24659                                     goto MATCH_label_a1008; break;
24660                                   default: assert(0);
24661                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
24662                               break;
24663                             case 1: 
24664                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
24665                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
24666                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24667                                       /* index at 16 */ && 
24668                                 (MATCH_w_8_16 >> 3 & 0x7) 
24669                                       /* index at 16 */ < 8)) { 
24670                                 unsigned Mem = 1 + addressToPC(MATCH_p);
24671                                 nextPC = 4 + MATCH_p; 
24672                                 
24673                                 #line 1705 "machine/pentium/disassembler.m"
24674                                 
24675 
24676                                         sprintf (str,  "FSTENV", DIS_MEM);
24677 
24678                                 
24679 
24680                                 
24681                                 
24682                                 
24683                               } /*opt-block*//*opt-block+*/
24684                               else 
24685                                 goto MATCH_label_a1006;  /*opt-block+*/
24686                               
24687                               break;
24688                             case 2: 
24689                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
24690                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
24691                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24692                                       /* index at 16 */ && 
24693                                 (MATCH_w_8_16 >> 3 & 0x7) 
24694                                       /* index at 16 */ < 8)) 
24695                                 goto MATCH_label_a1007;  /*opt-block+*/
24696                               else 
24697                                 goto MATCH_label_a1008;  /*opt-block+*/
24698                               
24699                               break;
24700                             case 3: 
24701                               
24702                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
24703                                   case 0: 
24704                                     nextPC = 2 + MATCH_p; 
24705                                     
24706                                     #line 1424 "machine/pentium/disassembler.m"
24707                                     
24708 
24709                                             sprintf (str,  "F2XM1");
24710 
24711                                     
24712 
24713                                     
24714                                     
24715                                     
24716                                     
24717                                     break;
24718                                   case 1: 
24719                                     nextPC = 2 + MATCH_p; 
24720                                     
24721                                     #line 1783 "machine/pentium/disassembler.m"
24722                                     
24723 
24724                                             sprintf (str,  "FYL2X");
24725 
24726                                     
24727 
24728                                     
24729                                     
24730                                     
24731                                     
24732                                     break;
24733                                   case 2: 
24734                                     nextPC = 2 + MATCH_p; 
24735                                     
24736                                     #line 1657 "machine/pentium/disassembler.m"
24737                                     
24738 
24739                                             sprintf (str,  "FPTAN");
24740 
24741                                     
24742 
24743                                     
24744                                     
24745                                     
24746                                     
24747                                     break;
24748                                   case 3: 
24749                                     nextPC = 2 + MATCH_p; 
24750                                     
24751                                     #line 1648 "machine/pentium/disassembler.m"
24752                                     
24753 
24754                                             sprintf (str,  "FPATAN");
24755 
24756                                     
24757 
24758                                     
24759                                     
24760                                     
24761                                     
24762                                     break;
24763                                   case 4: 
24764                                     nextPC = 2 + MATCH_p; 
24765                                     
24766                                     #line 1780 "machine/pentium/disassembler.m"
24767                                     
24768 
24769                                             sprintf (str,  "FXTRACT");
24770 
24771                                     
24772 
24773                                     
24774                                     
24775                                     
24776                                     
24777                                     break;
24778                                   case 5: 
24779                                     nextPC = 2 + MATCH_p; 
24780                                     
24781                                     #line 1654 "machine/pentium/disassembler.m"
24782                                     
24783 
24784                                             sprintf (str,  "FPREM1");
24785 
24786                                     
24787 
24788                                     
24789                                     
24790                                     
24791                                     
24792                                     break;
24793                                   case 6: 
24794                                     nextPC = 2 + MATCH_p; 
24795                                     
24796                                     #line 1505 "machine/pentium/disassembler.m"
24797                                     
24798 
24799                                             sprintf (str,  "FDECSTP");
24800 
24801                                     
24802 
24803                                     
24804                                     
24805                                     
24806                                     
24807                                     break;
24808                                   case 7: 
24809                                     goto MATCH_label_a39; break;
24810                                   default: assert(0);
24811                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
24812                               break;
24813                             default: assert(0);
24814                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
24815                         break;
24816                       case 7: 
24817                         
24818                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
24819                             case 0: 
24820                               
24821                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
24822                                   case 0: case 1: case 2: case 3: case 6: 
24823                                   case 7: 
24824                                     { 
24825                                       unsigned Mem16 = 
24826                                         1 + addressToPC(MATCH_p);
24827                                       nextPC = 2 + MATCH_p; 
24828                                       
24829                                       #line 1702 "machine/pentium/disassembler.m"
24830                                       
24831 
24832                                               sprintf (str,  "FSTCW", DIS_MEM16);
24833 
24834                                       
24835 
24836                                       
24837                                       
24838                                       
24839                                     }
24840                                     
24841                                     break;
24842                                   case 4: 
24843                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
24844                                     if ((MATCH_w_8_16 & 0x7) 
24845                                             /* base at 16 */ == 5 && 
24846                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24847                                             /* index at 16 */ && 
24848                                       (MATCH_w_8_16 >> 3 & 0x7) 
24849                                             /* index at 16 */ < 8)) 
24850                                       goto MATCH_label_a1010;  /*opt-block+*/
24851                                     else 
24852                                       goto MATCH_label_a1009;  /*opt-block+*/
24853                                     
24854                                     break;
24855                                   case 5: 
24856                                     goto MATCH_label_a1011; break;
24857                                   default: assert(0);
24858                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
24859                               break;
24860                             case 1: 
24861                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
24862                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
24863                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24864                                       /* index at 16 */ && 
24865                                 (MATCH_w_8_16 >> 3 & 0x7) 
24866                                       /* index at 16 */ < 8)) { 
24867                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
24868                                 nextPC = 4 + MATCH_p; 
24869                                 
24870                                 #line 1702 "machine/pentium/disassembler.m"
24871                                 
24872 
24873                                         sprintf (str,  "FSTCW", DIS_MEM16);
24874 
24875                                 
24876 
24877                                 
24878                                 
24879                                 
24880                               } /*opt-block*//*opt-block+*/
24881                               else 
24882                                 goto MATCH_label_a1009;  /*opt-block+*/
24883                               
24884                               break;
24885                             case 2: 
24886                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
24887                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
24888                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
24889                                       /* index at 16 */ && 
24890                                 (MATCH_w_8_16 >> 3 & 0x7) 
24891                                       /* index at 16 */ < 8)) 
24892                                 goto MATCH_label_a1010;  /*opt-block+*/
24893                               else 
24894                                 goto MATCH_label_a1011;  /*opt-block+*/
24895                               
24896                               break;
24897                             case 3: 
24898                               
24899                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
24900                                   case 0: 
24901                                     nextPC = 2 + MATCH_p; 
24902                                     
24903                                     #line 1651 "machine/pentium/disassembler.m"
24904                                     
24905 
24906                                             sprintf (str,  "FPREM");
24907 
24908                                     
24909 
24910                                     
24911                                     
24912                                     
24913                                     
24914                                     break;
24915                                   case 1: 
24916                                     nextPC = 2 + MATCH_p; 
24917                                     
24918                                     #line 1786 "machine/pentium/disassembler.m"
24919                                     
24920 
24921                                             sprintf (str,  "FYL2XP1");
24922 
24923                                     
24924 
24925                                     //  | inst = n =>
24926 
24927                                     //      sprintf (str, "%0x", n);
24928 
24929                                     
24930 
24931                                     
24932                                     
24933                                     
24934                                     
24935                                     break;
24936                                   case 2: 
24937                                     nextPC = 2 + MATCH_p; 
24938                                     
24939                                     #line 1678 "machine/pentium/disassembler.m"
24940                                     
24941 
24942                                             sprintf (str,  "FSQRT");
24943 
24944                                     
24945 
24946                                     
24947                                     
24948                                     
24949                                     
24950                                     break;
24951                                   case 3: 
24952                                     nextPC = 2 + MATCH_p; 
24953                                     
24954                                     #line 1675 "machine/pentium/disassembler.m"
24955                                     
24956 
24957                                             sprintf (str,  "FSINCOS");
24958 
24959                                     
24960 
24961                                     
24962                                     
24963                                     
24964                                     
24965                                     break;
24966                                   case 4: 
24967                                     nextPC = 2 + MATCH_p; 
24968                                     
24969                                     #line 1660 "machine/pentium/disassembler.m"
24970                                     
24971 
24972                                             sprintf (str,  "FRNDINT");
24973 
24974                                     
24975 
24976                                     
24977                                     
24978                                     
24979                                     
24980                                     break;
24981                                   case 5: 
24982                                     nextPC = 2 + MATCH_p; 
24983                                     
24984                                     #line 1669 "machine/pentium/disassembler.m"
24985                                     
24986 
24987                                             sprintf (str,  "FSCALE");
24988 
24989                                     
24990 
24991                                     
24992                                     
24993                                     
24994                                     
24995                                     break;
24996                                   case 6: 
24997                                     nextPC = 2 + MATCH_p; 
24998                                     
24999                                     #line 1672 "machine/pentium/disassembler.m"
25000                                     
25001 
25002                                             sprintf (str,  "FSIN");
25003 
25004                                     
25005 
25006                                     
25007                                     
25008                                     
25009                                     
25010                                     break;
25011                                   case 7: 
25012                                     nextPC = 2 + MATCH_p; 
25013                                     
25014                                     #line 1502 "machine/pentium/disassembler.m"
25015                                     
25016 
25017                                             sprintf (str,  "FCOS");
25018 
25019                                     
25020 
25021                                     
25022                                     
25023                                     
25024                                     
25025                                     break;
25026                                   default: assert(0);
25027                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
25028                               break;
25029                             default: assert(0);
25030                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
25031                         break;
25032                       default: assert(0);
25033                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
25034                   
25035                   break;
25036                 case 2: 
25037                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
25038                   
25039                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
25040                       case 0: 
25041                         
25042                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
25043                             case 0: 
25044                               
25045                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
25046                                   case 0: case 1: case 2: case 3: case 6: 
25047                                   case 7: 
25048                                     { 
25049                                       unsigned Mem32 = 
25050                                         1 + addressToPC(MATCH_p);
25051                                       nextPC = 2 + MATCH_p; 
25052                                       
25053                                       #line 1445 "machine/pentium/disassembler.m"
25054                                       
25055 
25056                                               sprintf (str,  "FIADD.I32", DIS_MEM32);
25057 
25058                                       
25059 
25060                                       
25061                                       
25062                                       
25063                                     }
25064                                     
25065                                     break;
25066                                   case 4: 
25067                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
25068                                     if ((MATCH_w_8_16 & 0x7) 
25069                                             /* base at 16 */ == 5 && 
25070                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25071                                             /* index at 16 */ && 
25072                                       (MATCH_w_8_16 >> 3 & 0x7) 
25073                                             /* index at 16 */ < 8)) 
25074                                       goto MATCH_label_a1013;  /*opt-block+*/
25075                                     else 
25076                                       goto MATCH_label_a1012;  /*opt-block+*/
25077                                     
25078                                     break;
25079                                   case 5: 
25080                                     goto MATCH_label_a1014; break;
25081                                   default: assert(0);
25082                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
25083                               break;
25084                             case 1: 
25085                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25086                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25087                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25088                                       /* index at 16 */ && 
25089                                 (MATCH_w_8_16 >> 3 & 0x7) 
25090                                       /* index at 16 */ < 8)) { 
25091                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
25092                                 nextPC = 4 + MATCH_p; 
25093                                 
25094                                 #line 1445 "machine/pentium/disassembler.m"
25095                                 
25096 
25097                                         sprintf (str,  "FIADD.I32", DIS_MEM32);
25098 
25099                                 
25100 
25101                                 
25102                                 
25103                                 
25104                               } /*opt-block*//*opt-block+*/
25105                               else 
25106                                 goto MATCH_label_a1012;  /*opt-block+*/
25107                               
25108                               break;
25109                             case 2: 
25110                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25111                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25112                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25113                                       /* index at 16 */ && 
25114                                 (MATCH_w_8_16 >> 3 & 0x7) 
25115                                       /* index at 16 */ < 8)) 
25116                                 goto MATCH_label_a1013;  /*opt-block+*/
25117                               else 
25118                                 goto MATCH_label_a1014;  /*opt-block+*/
25119                               
25120                               break;
25121                             case 3: 
25122                               goto MATCH_label_a39; break;
25123                             default: assert(0);
25124                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
25125                         break;
25126                       case 1: 
25127                         
25128                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
25129                             case 0: 
25130                               
25131                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
25132                                   case 0: case 1: case 2: case 3: case 6: 
25133                                   case 7: 
25134                                     { 
25135                                       unsigned Mem32 = 
25136                                         1 + addressToPC(MATCH_p);
25137                                       nextPC = 2 + MATCH_p; 
25138                                       
25139                                       #line 1639 "machine/pentium/disassembler.m"
25140                                       
25141 
25142                                               sprintf (str,  "FIMUL.I32", DIS_MEM32);
25143 
25144                                       
25145 
25146                                       
25147                                       
25148                                       
25149                                     }
25150                                     
25151                                     break;
25152                                   case 4: 
25153                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
25154                                     if ((MATCH_w_8_16 & 0x7) 
25155                                             /* base at 16 */ == 5 && 
25156                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25157                                             /* index at 16 */ && 
25158                                       (MATCH_w_8_16 >> 3 & 0x7) 
25159                                             /* index at 16 */ < 8)) 
25160                                       goto MATCH_label_a1016;  /*opt-block+*/
25161                                     else 
25162                                       goto MATCH_label_a1015;  /*opt-block+*/
25163                                     
25164                                     break;
25165                                   case 5: 
25166                                     goto MATCH_label_a1017; break;
25167                                   default: assert(0);
25168                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
25169                               break;
25170                             case 1: 
25171                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25172                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25173                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25174                                       /* index at 16 */ && 
25175                                 (MATCH_w_8_16 >> 3 & 0x7) 
25176                                       /* index at 16 */ < 8)) { 
25177                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
25178                                 nextPC = 4 + MATCH_p; 
25179                                 
25180                                 #line 1639 "machine/pentium/disassembler.m"
25181                                 
25182 
25183                                         sprintf (str,  "FIMUL.I32", DIS_MEM32);
25184 
25185                                 
25186 
25187                                 
25188                                 
25189                                 
25190                               } /*opt-block*//*opt-block+*/
25191                               else 
25192                                 goto MATCH_label_a1015;  /*opt-block+*/
25193                               
25194                               break;
25195                             case 2: 
25196                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25197                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25198                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25199                                       /* index at 16 */ && 
25200                                 (MATCH_w_8_16 >> 3 & 0x7) 
25201                                       /* index at 16 */ < 8)) 
25202                                 goto MATCH_label_a1016;  /*opt-block+*/
25203                               else 
25204                                 goto MATCH_label_a1017;  /*opt-block+*/
25205                               
25206                               break;
25207                             case 3: 
25208                               goto MATCH_label_a39; break;
25209                             default: assert(0);
25210                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
25211                         break;
25212                       case 2: 
25213                         
25214                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
25215                             case 0: 
25216                               
25217                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
25218                                   case 0: case 1: case 2: case 3: case 6: 
25219                                   case 7: 
25220                                     { 
25221                                       unsigned Mem32 = 
25222                                         1 + addressToPC(MATCH_p);
25223                                       nextPC = 2 + MATCH_p; 
25224                                       
25225                                       #line 1469 "machine/pentium/disassembler.m"
25226                                       
25227 
25228                                               sprintf (str,  "FICOM.I32", DIS_MEM32);
25229 
25230                                       
25231 
25232                                       
25233                                       
25234                                       
25235                                     }
25236                                     
25237                                     break;
25238                                   case 4: 
25239                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
25240                                     if ((MATCH_w_8_16 & 0x7) 
25241                                             /* base at 16 */ == 5 && 
25242                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25243                                             /* index at 16 */ && 
25244                                       (MATCH_w_8_16 >> 3 & 0x7) 
25245                                             /* index at 16 */ < 8)) 
25246                                       goto MATCH_label_a1019;  /*opt-block+*/
25247                                     else 
25248                                       goto MATCH_label_a1018;  /*opt-block+*/
25249                                     
25250                                     break;
25251                                   case 5: 
25252                                     goto MATCH_label_a1020; break;
25253                                   default: assert(0);
25254                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
25255                               break;
25256                             case 1: 
25257                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25258                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25259                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25260                                       /* index at 16 */ && 
25261                                 (MATCH_w_8_16 >> 3 & 0x7) 
25262                                       /* index at 16 */ < 8)) { 
25263                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
25264                                 nextPC = 4 + MATCH_p; 
25265                                 
25266                                 #line 1469 "machine/pentium/disassembler.m"
25267                                 
25268 
25269                                         sprintf (str,  "FICOM.I32", DIS_MEM32);
25270 
25271                                 
25272 
25273                                 
25274                                 
25275                                 
25276                               } /*opt-block*//*opt-block+*/
25277                               else 
25278                                 goto MATCH_label_a1018;  /*opt-block+*/
25279                               
25280                               break;
25281                             case 2: 
25282                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25283                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25284                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25285                                       /* index at 16 */ && 
25286                                 (MATCH_w_8_16 >> 3 & 0x7) 
25287                                       /* index at 16 */ < 8)) 
25288                                 goto MATCH_label_a1019;  /*opt-block+*/
25289                               else 
25290                                 goto MATCH_label_a1020;  /*opt-block+*/
25291                               
25292                               break;
25293                             case 3: 
25294                               goto MATCH_label_a39; break;
25295                             default: assert(0);
25296                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
25297                         break;
25298                       case 3: 
25299                         
25300                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
25301                             case 0: 
25302                               
25303                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
25304                                   case 0: case 1: case 2: case 3: case 6: 
25305                                   case 7: 
25306                                     { 
25307                                       unsigned Mem32 = 
25308                                         1 + addressToPC(MATCH_p);
25309                                       nextPC = 2 + MATCH_p; 
25310                                       
25311                                       #line 1487 "machine/pentium/disassembler.m"
25312                                       
25313 
25314                                               sprintf (str,  "FICOMP.I32", DIS_MEM32);
25315 
25316                                       
25317 
25318                                       
25319                                       
25320                                       
25321                                     }
25322                                     
25323                                     break;
25324                                   case 4: 
25325                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
25326                                     if ((MATCH_w_8_16 & 0x7) 
25327                                             /* base at 16 */ == 5 && 
25328                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25329                                             /* index at 16 */ && 
25330                                       (MATCH_w_8_16 >> 3 & 0x7) 
25331                                             /* index at 16 */ < 8)) 
25332                                       goto MATCH_label_a1022;  /*opt-block+*/
25333                                     else 
25334                                       goto MATCH_label_a1021;  /*opt-block+*/
25335                                     
25336                                     break;
25337                                   case 5: 
25338                                     goto MATCH_label_a1023; break;
25339                                   default: assert(0);
25340                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
25341                               break;
25342                             case 1: 
25343                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25344                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25345                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25346                                       /* index at 16 */ && 
25347                                 (MATCH_w_8_16 >> 3 & 0x7) 
25348                                       /* index at 16 */ < 8)) { 
25349                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
25350                                 nextPC = 4 + MATCH_p; 
25351                                 
25352                                 #line 1487 "machine/pentium/disassembler.m"
25353                                 
25354 
25355                                         sprintf (str,  "FICOMP.I32", DIS_MEM32);
25356 
25357                                 
25358 
25359                                 
25360                                 
25361                                 
25362                               } /*opt-block*//*opt-block+*/
25363                               else 
25364                                 goto MATCH_label_a1021;  /*opt-block+*/
25365                               
25366                               break;
25367                             case 2: 
25368                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25369                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25370                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25371                                       /* index at 16 */ && 
25372                                 (MATCH_w_8_16 >> 3 & 0x7) 
25373                                       /* index at 16 */ < 8)) 
25374                                 goto MATCH_label_a1022;  /*opt-block+*/
25375                               else 
25376                                 goto MATCH_label_a1023;  /*opt-block+*/
25377                               
25378                               break;
25379                             case 3: 
25380                               goto MATCH_label_a39; break;
25381                             default: assert(0);
25382                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
25383                         break;
25384                       case 4: 
25385                         
25386                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
25387                             case 0: 
25388                               
25389                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
25390                                   case 0: case 1: case 2: case 3: case 6: 
25391                                   case 7: 
25392                                     { 
25393                                       unsigned Mem32 = 
25394                                         1 + addressToPC(MATCH_p);
25395                                       nextPC = 2 + MATCH_p; 
25396                                       
25397                                       #line 1726 "machine/pentium/disassembler.m"
25398                                       
25399 
25400                                               sprintf (str,  "FISUB.I32", DIS_MEM32);
25401 
25402                                       
25403 
25404                                       
25405                                       
25406                                       
25407                                     }
25408                                     
25409                                     break;
25410                                   case 4: 
25411                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
25412                                     if ((MATCH_w_8_16 & 0x7) 
25413                                             /* base at 16 */ == 5 && 
25414                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25415                                             /* index at 16 */ && 
25416                                       (MATCH_w_8_16 >> 3 & 0x7) 
25417                                             /* index at 16 */ < 8)) 
25418                                       goto MATCH_label_a1025;  /*opt-block+*/
25419                                     else 
25420                                       goto MATCH_label_a1024;  /*opt-block+*/
25421                                     
25422                                     break;
25423                                   case 5: 
25424                                     goto MATCH_label_a1026; break;
25425                                   default: assert(0);
25426                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
25427                               break;
25428                             case 1: 
25429                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25430                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25431                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25432                                       /* index at 16 */ && 
25433                                 (MATCH_w_8_16 >> 3 & 0x7) 
25434                                       /* index at 16 */ < 8)) { 
25435                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
25436                                 nextPC = 4 + MATCH_p; 
25437                                 
25438                                 #line 1726 "machine/pentium/disassembler.m"
25439                                 
25440 
25441                                         sprintf (str,  "FISUB.I32", DIS_MEM32);
25442 
25443                                 
25444 
25445                                 
25446                                 
25447                                 
25448                               } /*opt-block*//*opt-block+*/
25449                               else 
25450                                 goto MATCH_label_a1024;  /*opt-block+*/
25451                               
25452                               break;
25453                             case 2: 
25454                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25455                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25456                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25457                                       /* index at 16 */ && 
25458                                 (MATCH_w_8_16 >> 3 & 0x7) 
25459                                       /* index at 16 */ < 8)) 
25460                                 goto MATCH_label_a1025;  /*opt-block+*/
25461                               else 
25462                                 goto MATCH_label_a1026;  /*opt-block+*/
25463                               
25464                               break;
25465                             case 3: 
25466                               goto MATCH_label_a39; break;
25467                             default: assert(0);
25468                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
25469                         break;
25470                       case 5: 
25471                         
25472                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
25473                             case 0: 
25474                               
25475                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
25476                                   case 0: case 1: case 2: case 3: case 6: 
25477                                   case 7: 
25478                                     { 
25479                                       unsigned Mem32 = 
25480                                         1 + addressToPC(MATCH_p);
25481                                       nextPC = 2 + MATCH_p; 
25482                                       
25483                                       #line 1747 "machine/pentium/disassembler.m"
25484                                       
25485 
25486                                               sprintf (str,  "FISUBR.I32", DIS_MEM32);
25487 
25488                                       
25489 
25490                                       
25491                                       
25492                                       
25493                                     }
25494                                     
25495                                     break;
25496                                   case 4: 
25497                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
25498                                     if ((MATCH_w_8_16 & 0x7) 
25499                                             /* base at 16 */ == 5 && 
25500                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25501                                             /* index at 16 */ && 
25502                                       (MATCH_w_8_16 >> 3 & 0x7) 
25503                                             /* index at 16 */ < 8)) 
25504                                       goto MATCH_label_a1028;  /*opt-block+*/
25505                                     else 
25506                                       goto MATCH_label_a1027;  /*opt-block+*/
25507                                     
25508                                     break;
25509                                   case 5: 
25510                                     goto MATCH_label_a1029; break;
25511                                   default: assert(0);
25512                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
25513                               break;
25514                             case 1: 
25515                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25516                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25517                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25518                                       /* index at 16 */ && 
25519                                 (MATCH_w_8_16 >> 3 & 0x7) 
25520                                       /* index at 16 */ < 8)) { 
25521                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
25522                                 nextPC = 4 + MATCH_p; 
25523                                 
25524                                 #line 1747 "machine/pentium/disassembler.m"
25525                                 
25526 
25527                                         sprintf (str,  "FISUBR.I32", DIS_MEM32);
25528 
25529                                 
25530 
25531                                 
25532                                 
25533                                 
25534                               } /*opt-block*//*opt-block+*/
25535                               else 
25536                                 goto MATCH_label_a1027;  /*opt-block+*/
25537                               
25538                               break;
25539                             case 2: 
25540                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25541                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25542                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25543                                       /* index at 16 */ && 
25544                                 (MATCH_w_8_16 >> 3 & 0x7) 
25545                                       /* index at 16 */ < 8)) 
25546                                 goto MATCH_label_a1028;  /*opt-block+*/
25547                               else 
25548                                 goto MATCH_label_a1029;  /*opt-block+*/
25549                               
25550                               break;
25551                             case 3: 
25552                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 1) { 
25553                                 nextPC = 2 + MATCH_p; 
25554                                 
25555                                 #line 1765 "machine/pentium/disassembler.m"
25556                                 
25557 
25558                                         sprintf (str,  "FUCOMPP");
25559 
25560                                 
25561 
25562                                 
25563                                 
25564                                 
25565                               } /*opt-block*//*opt-block+*/
25566                               else 
25567                                 goto MATCH_label_a39;  /*opt-block+*/
25568                               
25569                               break;
25570                             default: assert(0);
25571                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
25572                         break;
25573                       case 6: 
25574                         
25575                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
25576                             case 0: 
25577                               
25578                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
25579                                   case 0: case 1: case 2: case 3: case 6: 
25580                                   case 7: 
25581                                     { 
25582                                       unsigned Mem32 = 
25583                                         1 + addressToPC(MATCH_p);
25584                                       nextPC = 2 + MATCH_p; 
25585                                       
25586                                       #line 1523 "machine/pentium/disassembler.m"
25587                                       
25588 
25589                                               sprintf (str,  "FIDIV.I32", DIS_MEM32);
25590 
25591                                       
25592 
25593                                       
25594                                       
25595                                       
25596                                     }
25597                                     
25598                                     break;
25599                                   case 4: 
25600                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
25601                                     if ((MATCH_w_8_16 & 0x7) 
25602                                             /* base at 16 */ == 5 && 
25603                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25604                                             /* index at 16 */ && 
25605                                       (MATCH_w_8_16 >> 3 & 0x7) 
25606                                             /* index at 16 */ < 8)) 
25607                                       goto MATCH_label_a1031;  /*opt-block+*/
25608                                     else 
25609                                       goto MATCH_label_a1030;  /*opt-block+*/
25610                                     
25611                                     break;
25612                                   case 5: 
25613                                     goto MATCH_label_a1032; break;
25614                                   default: assert(0);
25615                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
25616                               break;
25617                             case 1: 
25618                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25619                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25620                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25621                                       /* index at 16 */ && 
25622                                 (MATCH_w_8_16 >> 3 & 0x7) 
25623                                       /* index at 16 */ < 8)) { 
25624                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
25625                                 nextPC = 4 + MATCH_p; 
25626                                 
25627                                 #line 1523 "machine/pentium/disassembler.m"
25628                                 
25629 
25630                                         sprintf (str,  "FIDIV.I32", DIS_MEM32);
25631 
25632                                 
25633 
25634                                 
25635                                 
25636                                 
25637                               } /*opt-block*//*opt-block+*/
25638                               else 
25639                                 goto MATCH_label_a1030;  /*opt-block+*/
25640                               
25641                               break;
25642                             case 2: 
25643                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25644                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25645                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25646                                       /* index at 16 */ && 
25647                                 (MATCH_w_8_16 >> 3 & 0x7) 
25648                                       /* index at 16 */ < 8)) 
25649                                 goto MATCH_label_a1031;  /*opt-block+*/
25650                               else 
25651                                 goto MATCH_label_a1032;  /*opt-block+*/
25652                               
25653                               break;
25654                             case 3: 
25655                               goto MATCH_label_a39; break;
25656                             default: assert(0);
25657                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
25658                         break;
25659                       case 7: 
25660                         
25661                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
25662                             case 0: 
25663                               
25664                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
25665                                   case 0: case 1: case 2: case 3: case 6: 
25666                                   case 7: 
25667                                     { 
25668                                       unsigned Mem32 = 
25669                                         1 + addressToPC(MATCH_p);
25670                                       nextPC = 2 + MATCH_p; 
25671                                       
25672                                       #line 1541 "machine/pentium/disassembler.m"
25673                                       
25674 
25675                                               sprintf (str,  "FIDIVR.I32", DIS_MEM32);
25676 
25677                                       
25678 
25679                                       
25680                                       
25681                                       
25682                                     }
25683                                     
25684                                     break;
25685                                   case 4: 
25686                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
25687                                     if ((MATCH_w_8_16 & 0x7) 
25688                                             /* base at 16 */ == 5 && 
25689                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25690                                             /* index at 16 */ && 
25691                                       (MATCH_w_8_16 >> 3 & 0x7) 
25692                                             /* index at 16 */ < 8)) 
25693                                       goto MATCH_label_a1034;  /*opt-block+*/
25694                                     else 
25695                                       goto MATCH_label_a1033;  /*opt-block+*/
25696                                     
25697                                     break;
25698                                   case 5: 
25699                                     goto MATCH_label_a1035; break;
25700                                   default: assert(0);
25701                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
25702                               break;
25703                             case 1: 
25704                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25705                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25706                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25707                                       /* index at 16 */ && 
25708                                 (MATCH_w_8_16 >> 3 & 0x7) 
25709                                       /* index at 16 */ < 8)) { 
25710                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
25711                                 nextPC = 4 + MATCH_p; 
25712                                 
25713                                 #line 1541 "machine/pentium/disassembler.m"
25714                                 
25715 
25716                                         sprintf (str,  "FIDIVR.I32", DIS_MEM32);
25717 
25718                                 
25719 
25720                                 
25721                                 
25722                                 
25723                               } /*opt-block*//*opt-block+*/
25724                               else 
25725                                 goto MATCH_label_a1033;  /*opt-block+*/
25726                               
25727                               break;
25728                             case 2: 
25729                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25730                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25731                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25732                                       /* index at 16 */ && 
25733                                 (MATCH_w_8_16 >> 3 & 0x7) 
25734                                       /* index at 16 */ < 8)) 
25735                                 goto MATCH_label_a1034;  /*opt-block+*/
25736                               else 
25737                                 goto MATCH_label_a1035;  /*opt-block+*/
25738                               
25739                               break;
25740                             case 3: 
25741                               goto MATCH_label_a39; break;
25742                             default: assert(0);
25743                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
25744                         break;
25745                       default: assert(0);
25746                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
25747                   
25748                   break;
25749                 case 3: 
25750                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
25751                   
25752                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
25753                       case 0: 
25754                         
25755                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
25756                             case 0: 
25757                               
25758                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
25759                                   case 0: case 1: case 2: case 3: case 6: 
25760                                   case 7: 
25761                                     { 
25762                                       unsigned Mem32 = 
25763                                         1 + addressToPC(MATCH_p);
25764                                       nextPC = 2 + MATCH_p; 
25765                                       
25766                                       #line 1556 "machine/pentium/disassembler.m"
25767                                       
25768 
25769                                               sprintf (str,  "FILD.lsI32", DIS_MEM32);
25770 
25771                                       
25772 
25773                                       
25774                                       
25775                                       
25776                                     }
25777                                     
25778                                     break;
25779                                   case 4: 
25780                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
25781                                     if ((MATCH_w_8_16 & 0x7) 
25782                                             /* base at 16 */ == 5 && 
25783                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25784                                             /* index at 16 */ && 
25785                                       (MATCH_w_8_16 >> 3 & 0x7) 
25786                                             /* index at 16 */ < 8)) 
25787                                       goto MATCH_label_a1037;  /*opt-block+*/
25788                                     else 
25789                                       goto MATCH_label_a1036;  /*opt-block+*/
25790                                     
25791                                     break;
25792                                   case 5: 
25793                                     goto MATCH_label_a1038; break;
25794                                   default: assert(0);
25795                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
25796                               break;
25797                             case 1: 
25798                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25799                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25800                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25801                                       /* index at 16 */ && 
25802                                 (MATCH_w_8_16 >> 3 & 0x7) 
25803                                       /* index at 16 */ < 8)) { 
25804                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
25805                                 nextPC = 4 + MATCH_p; 
25806                                 
25807                                 #line 1556 "machine/pentium/disassembler.m"
25808                                 
25809 
25810                                         sprintf (str,  "FILD.lsI32", DIS_MEM32);
25811 
25812                                 
25813 
25814                                 
25815                                 
25816                                 
25817                               } /*opt-block*//*opt-block+*/
25818                               else 
25819                                 goto MATCH_label_a1036;  /*opt-block+*/
25820                               
25821                               break;
25822                             case 2: 
25823                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25824                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25825                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25826                                       /* index at 16 */ && 
25827                                 (MATCH_w_8_16 >> 3 & 0x7) 
25828                                       /* index at 16 */ < 8)) 
25829                                 goto MATCH_label_a1037;  /*opt-block+*/
25830                               else 
25831                                 goto MATCH_label_a1038;  /*opt-block+*/
25832                               
25833                               break;
25834                             case 3: 
25835                               goto MATCH_label_a39; break;
25836                             default: assert(0);
25837                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
25838                         break;
25839                       case 1: 
25840                         goto MATCH_label_a39; break;
25841                       case 2: 
25842                         
25843                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
25844                             case 0: 
25845                               
25846                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
25847                                   case 0: case 1: case 2: case 3: case 6: 
25848                                   case 7: 
25849                                     { 
25850                                       unsigned Mem32 = 
25851                                         1 + addressToPC(MATCH_p);
25852                                       nextPC = 2 + MATCH_p; 
25853                                       
25854                                       #line 1568 "machine/pentium/disassembler.m"
25855                                       
25856 
25857                                               sprintf (str,  "FIST.lsI32", DIS_MEM32);
25858 
25859                                       
25860 
25861                                       
25862                                       
25863                                       
25864                                     }
25865                                     
25866                                     break;
25867                                   case 4: 
25868                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
25869                                     if ((MATCH_w_8_16 & 0x7) 
25870                                             /* base at 16 */ == 5 && 
25871                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25872                                             /* index at 16 */ && 
25873                                       (MATCH_w_8_16 >> 3 & 0x7) 
25874                                             /* index at 16 */ < 8)) 
25875                                       goto MATCH_label_a1040;  /*opt-block+*/
25876                                     else 
25877                                       goto MATCH_label_a1039;  /*opt-block+*/
25878                                     
25879                                     break;
25880                                   case 5: 
25881                                     goto MATCH_label_a1041; break;
25882                                   default: assert(0);
25883                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
25884                               break;
25885                             case 1: 
25886                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25887                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25888                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25889                                       /* index at 16 */ && 
25890                                 (MATCH_w_8_16 >> 3 & 0x7) 
25891                                       /* index at 16 */ < 8)) { 
25892                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
25893                                 nextPC = 4 + MATCH_p; 
25894                                 
25895                                 #line 1568 "machine/pentium/disassembler.m"
25896                                 
25897 
25898                                         sprintf (str,  "FIST.lsI32", DIS_MEM32);
25899 
25900                                 
25901 
25902                                 
25903                                 
25904                                 
25905                               } /*opt-block*//*opt-block+*/
25906                               else 
25907                                 goto MATCH_label_a1039;  /*opt-block+*/
25908                               
25909                               break;
25910                             case 2: 
25911                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25912                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25913                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25914                                       /* index at 16 */ && 
25915                                 (MATCH_w_8_16 >> 3 & 0x7) 
25916                                       /* index at 16 */ < 8)) 
25917                                 goto MATCH_label_a1040;  /*opt-block+*/
25918                               else 
25919                                 goto MATCH_label_a1041;  /*opt-block+*/
25920                               
25921                               break;
25922                             case 3: 
25923                               goto MATCH_label_a39; break;
25924                             default: assert(0);
25925                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
25926                         break;
25927                       case 3: 
25928                         
25929                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
25930                             case 0: 
25931                               
25932                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
25933                                   case 0: case 1: case 2: case 3: case 6: 
25934                                   case 7: 
25935                                     { 
25936                                       unsigned Mem32 = 
25937                                         1 + addressToPC(MATCH_p);
25938                                       nextPC = 2 + MATCH_p; 
25939                                       
25940                                       #line 1574 "machine/pentium/disassembler.m"
25941                                       
25942 
25943                                               sprintf (str,  "FISTP.lsI32", DIS_MEM32);
25944 
25945                                       
25946 
25947                                       
25948                                       
25949                                       
25950                                     }
25951                                     
25952                                     break;
25953                                   case 4: 
25954                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
25955                                     if ((MATCH_w_8_16 & 0x7) 
25956                                             /* base at 16 */ == 5 && 
25957                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25958                                             /* index at 16 */ && 
25959                                       (MATCH_w_8_16 >> 3 & 0x7) 
25960                                             /* index at 16 */ < 8)) 
25961                                       goto MATCH_label_a1043;  /*opt-block+*/
25962                                     else 
25963                                       goto MATCH_label_a1042;  /*opt-block+*/
25964                                     
25965                                     break;
25966                                   case 5: 
25967                                     goto MATCH_label_a1044; break;
25968                                   default: assert(0);
25969                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
25970                               break;
25971                             case 1: 
25972                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25973                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25974                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
25975                                       /* index at 16 */ && 
25976                                 (MATCH_w_8_16 >> 3 & 0x7) 
25977                                       /* index at 16 */ < 8)) { 
25978                                 unsigned Mem32 = 1 + addressToPC(MATCH_p);
25979                                 nextPC = 4 + MATCH_p; 
25980                                 
25981                                 #line 1574 "machine/pentium/disassembler.m"
25982                                 
25983 
25984                                         sprintf (str,  "FISTP.lsI32", DIS_MEM32);
25985 
25986                                 
25987 
25988                                 
25989                                 
25990                                 
25991                               } /*opt-block*//*opt-block+*/
25992                               else 
25993                                 goto MATCH_label_a1042;  /*opt-block+*/
25994                               
25995                               break;
25996                             case 2: 
25997                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
25998                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
25999                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26000                                       /* index at 16 */ && 
26001                                 (MATCH_w_8_16 >> 3 & 0x7) 
26002                                       /* index at 16 */ < 8)) 
26003                                 goto MATCH_label_a1043;  /*opt-block+*/
26004                               else 
26005                                 goto MATCH_label_a1044;  /*opt-block+*/
26006                               
26007                               break;
26008                             case 3: 
26009                               goto MATCH_label_a39; break;
26010                             default: assert(0);
26011                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
26012                         break;
26013                       case 4: 
26014                         
26015                           switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
26016                             case 0: case 1: case 4: case 5: case 6: case 7: 
26017                               goto MATCH_label_a39; break;
26018                             case 2: 
26019                               if ((MATCH_w_8_8 >> 6 & 0x3) 
26020                                       /* mod at 8 */ == 3) { 
26021                                 nextPC = 2 + MATCH_p; 
26022                                 
26023                                 #line 1460 "machine/pentium/disassembler.m"
26024                                 
26025 
26026                                         sprintf (str,  "FNCLEX");
26027 
26028                                 
26029 
26030                                 
26031                                 
26032                                 
26033                               } /*opt-block*//*opt-block+*/
26034                               else 
26035                                 goto MATCH_label_a39;  /*opt-block+*/
26036                               
26037                               break;
26038                             case 3: 
26039                               if ((MATCH_w_8_8 >> 6 & 0x3) 
26040                                       /* mod at 8 */ == 3) { 
26041                                 nextPC = 2 + MATCH_p; 
26042                                 
26043                                 #line 1562 "machine/pentium/disassembler.m"
26044                                 
26045 
26046                                         sprintf (str,  "FINIT");
26047 
26048                                 
26049 
26050                                 
26051                                 
26052                                 
26053                               } /*opt-block*//*opt-block+*/
26054                               else 
26055                                 goto MATCH_label_a39;  /*opt-block+*/
26056                               
26057                               break;
26058                             default: assert(0);
26059                           } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
26060                         break;
26061                       case 5: 
26062                         
26063                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
26064                             case 0: 
26065                               
26066                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
26067                                   case 0: case 1: case 2: case 3: case 6: 
26068                                   case 7: 
26069                                     { 
26070                                       unsigned Mem80 = 
26071                                         1 + addressToPC(MATCH_p);
26072                                       nextPC = 2 + MATCH_p; 
26073                                       
26074                                       #line 1586 "machine/pentium/disassembler.m"
26075                                       
26076 
26077                                               sprintf (str,  "FLD80", DIS_MEM80);
26078 
26079                                       
26080 
26081                                       /* This is a bit tricky. The FPUSH logically comes between the read of STi and
26082 
26083                                       # the write to ST0. In particular, FLD ST0 is supposed to duplicate the TOS.
26084 
26085                                       # This problem only happens with this load instruction, so there is a work
26086 
26087                                       # around here that gives us the SSL a value of i that is one more than in
26088 
26089                                       # the instruction */
26090 
26091                                       
26092                                       
26093                                       
26094                                     }
26095                                     
26096                                     break;
26097                                   case 4: 
26098                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
26099                                     if ((MATCH_w_8_16 & 0x7) 
26100                                             /* base at 16 */ == 5 && 
26101                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26102                                             /* index at 16 */ && 
26103                                       (MATCH_w_8_16 >> 3 & 0x7) 
26104                                             /* index at 16 */ < 8)) 
26105                                       goto MATCH_label_a1046;  /*opt-block+*/
26106                                     else 
26107                                       goto MATCH_label_a1045;  /*opt-block+*/
26108                                     
26109                                     break;
26110                                   case 5: 
26111                                     goto MATCH_label_a1047; break;
26112                                   default: assert(0);
26113                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
26114                               break;
26115                             case 1: 
26116                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
26117                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
26118                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26119                                       /* index at 16 */ && 
26120                                 (MATCH_w_8_16 >> 3 & 0x7) 
26121                                       /* index at 16 */ < 8)) { 
26122                                 unsigned Mem80 = 1 + addressToPC(MATCH_p);
26123                                 nextPC = 4 + MATCH_p; 
26124                                 
26125                                 #line 1586 "machine/pentium/disassembler.m"
26126                                 
26127 
26128                                         sprintf (str,  "FLD80", DIS_MEM80);
26129 
26130                                 
26131 
26132                                 /* This is a bit tricky. The FPUSH logically comes between the read of STi and
26133 
26134                                 # the write to ST0. In particular, FLD ST0 is supposed to duplicate the TOS.
26135 
26136                                 # This problem only happens with this load instruction, so there is a work
26137 
26138                                 # around here that gives us the SSL a value of i that is one more than in
26139 
26140                                 # the instruction */
26141 
26142                                 
26143                                 
26144                                 
26145                               } /*opt-block*//*opt-block+*/
26146                               else 
26147                                 goto MATCH_label_a1045;  /*opt-block+*/
26148                               
26149                               break;
26150                             case 2: 
26151                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
26152                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
26153                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26154                                       /* index at 16 */ && 
26155                                 (MATCH_w_8_16 >> 3 & 0x7) 
26156                                       /* index at 16 */ < 8)) 
26157                                 goto MATCH_label_a1046;  /*opt-block+*/
26158                               else 
26159                                 goto MATCH_label_a1047;  /*opt-block+*/
26160                               
26161                               break;
26162                             case 3: 
26163                               MATCH_name = "FUCOMI.ST.STi"; 
26164                               { 
26165                                 char *name = MATCH_name;
26166                                 unsigned idx = 
26167                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
26168                                 nextPC = 2 + MATCH_p; 
26169                                 
26170                                 #line 1768 "machine/pentium/disassembler.m"
26171                                 
26172 
26173                                         sprintf (str, name, DIS_IDX);
26174 
26175                                 
26176 
26177                                 
26178                                 
26179                                 
26180                               }
26181                               
26182                               break;
26183                             default: assert(0);
26184                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
26185                         break;
26186                       case 6: 
26187                         if ((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */ == 3) { 
26188                           MATCH_name = "FCOMI.ST.STi"; 
26189                           { 
26190                             char *name = MATCH_name;
26191                             unsigned idx = (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
26192                             nextPC = 2 + MATCH_p; 
26193                             
26194                             #line 1496 "machine/pentium/disassembler.m"
26195                             
26196 
26197                                     sprintf (str, name, DIS_IDX);
26198 
26199                             
26200 
26201                             
26202                             
26203                             
26204                           }
26205                           
26206                         } /*opt-block*/
26207                         else 
26208                           goto MATCH_label_a39;  /*opt-block+*/
26209                         
26210                         break;
26211                       case 7: 
26212                         
26213                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
26214                             case 0: 
26215                               
26216                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
26217                                   case 0: case 1: case 2: case 3: case 6: 
26218                                   case 7: 
26219                                     { 
26220                                       unsigned Mem80 = 
26221                                         1 + addressToPC(MATCH_p);
26222                                       nextPC = 2 + MATCH_p; 
26223                                       
26224                                       #line 1693 "machine/pentium/disassembler.m"
26225                                       
26226 
26227                                               sprintf (str,  "FSTP80", DIS_MEM80);
26228 
26229                                       
26230 
26231                                       
26232                                       
26233                                       
26234                                     }
26235                                     
26236                                     break;
26237                                   case 4: 
26238                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
26239                                     if ((MATCH_w_8_16 & 0x7) 
26240                                             /* base at 16 */ == 5 && 
26241                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26242                                             /* index at 16 */ && 
26243                                       (MATCH_w_8_16 >> 3 & 0x7) 
26244                                             /* index at 16 */ < 8)) 
26245                                       goto MATCH_label_a1049;  /*opt-block+*/
26246                                     else 
26247                                       goto MATCH_label_a1048;  /*opt-block+*/
26248                                     
26249                                     break;
26250                                   case 5: 
26251                                     goto MATCH_label_a1050; break;
26252                                   default: assert(0);
26253                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
26254                               break;
26255                             case 1: 
26256                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
26257                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
26258                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26259                                       /* index at 16 */ && 
26260                                 (MATCH_w_8_16 >> 3 & 0x7) 
26261                                       /* index at 16 */ < 8)) { 
26262                                 unsigned Mem80 = 1 + addressToPC(MATCH_p);
26263                                 nextPC = 4 + MATCH_p; 
26264                                 
26265                                 #line 1693 "machine/pentium/disassembler.m"
26266                                 
26267 
26268                                         sprintf (str,  "FSTP80", DIS_MEM80);
26269 
26270                                 
26271 
26272                                 
26273                                 
26274                                 
26275                               } /*opt-block*//*opt-block+*/
26276                               else 
26277                                 goto MATCH_label_a1048;  /*opt-block+*/
26278                               
26279                               break;
26280                             case 2: 
26281                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
26282                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
26283                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26284                                       /* index at 16 */ && 
26285                                 (MATCH_w_8_16 >> 3 & 0x7) 
26286                                       /* index at 16 */ < 8)) 
26287                                 goto MATCH_label_a1049;  /*opt-block+*/
26288                               else 
26289                                 goto MATCH_label_a1050;  /*opt-block+*/
26290                               
26291                               break;
26292                             case 3: 
26293                               goto MATCH_label_a39; break;
26294                             default: assert(0);
26295                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
26296                         break;
26297                       default: assert(0);
26298                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
26299                   
26300                   break;
26301                 case 4: 
26302                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
26303                   
26304                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
26305                       case 0: 
26306                         
26307                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
26308                             case 0: 
26309                               
26310                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
26311                                   case 0: case 1: case 2: case 3: case 6: 
26312                                   case 7: 
26313                                     { 
26314                                       unsigned Mem64 = 
26315                                         1 + addressToPC(MATCH_p);
26316                                       nextPC = 2 + MATCH_p; 
26317                                       
26318                                       #line 1433 "machine/pentium/disassembler.m"
26319                                       
26320 
26321                                               sprintf (str,  "FADD.R64", DIS_MEM64);
26322 
26323                                       
26324 
26325                                       
26326                                       
26327                                       
26328                                     }
26329                                     
26330                                     break;
26331                                   case 4: 
26332                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
26333                                     if ((MATCH_w_8_16 & 0x7) 
26334                                             /* base at 16 */ == 5 && 
26335                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26336                                             /* index at 16 */ && 
26337                                       (MATCH_w_8_16 >> 3 & 0x7) 
26338                                             /* index at 16 */ < 8)) 
26339                                       goto MATCH_label_a1052;  /*opt-block+*/
26340                                     else 
26341                                       goto MATCH_label_a1051;  /*opt-block+*/
26342                                     
26343                                     break;
26344                                   case 5: 
26345                                     goto MATCH_label_a1053; break;
26346                                   default: assert(0);
26347                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
26348                               break;
26349                             case 1: 
26350                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
26351                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
26352                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26353                                       /* index at 16 */ && 
26354                                 (MATCH_w_8_16 >> 3 & 0x7) 
26355                                       /* index at 16 */ < 8)) { 
26356                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
26357                                 nextPC = 4 + MATCH_p; 
26358                                 
26359                                 #line 1433 "machine/pentium/disassembler.m"
26360                                 
26361 
26362                                         sprintf (str,  "FADD.R64", DIS_MEM64);
26363 
26364                                 
26365 
26366                                 
26367                                 
26368                                 
26369                               } /*opt-block*//*opt-block+*/
26370                               else 
26371                                 goto MATCH_label_a1051;  /*opt-block+*/
26372                               
26373                               break;
26374                             case 2: 
26375                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
26376                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
26377                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26378                                       /* index at 16 */ && 
26379                                 (MATCH_w_8_16 >> 3 & 0x7) 
26380                                       /* index at 16 */ < 8)) 
26381                                 goto MATCH_label_a1052;  /*opt-block+*/
26382                               else 
26383                                 goto MATCH_label_a1053;  /*opt-block+*/
26384                               
26385                               break;
26386                             case 3: 
26387                               { 
26388                                 unsigned idx = 
26389                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
26390                                 nextPC = 2 + MATCH_p; 
26391                                 
26392                                 #line 1439 "machine/pentium/disassembler.m"
26393                                 
26394 
26395                                         sprintf (str,  "FADD.STi.ST", DIS_IDX);
26396 
26397                                 
26398 
26399                                 
26400                                 
26401                                 
26402                               }
26403                               
26404                               break;
26405                             default: assert(0);
26406                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
26407                         break;
26408                       case 1: 
26409                         
26410                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
26411                             case 0: 
26412                               
26413                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
26414                                   case 0: case 1: case 2: case 3: case 6: 
26415                                   case 7: 
26416                                     { 
26417                                       unsigned Mem64 = 
26418                                         1 + addressToPC(MATCH_p);
26419                                       nextPC = 2 + MATCH_p; 
26420                                       
26421                                       #line 1627 "machine/pentium/disassembler.m"
26422                                       
26423 
26424                                               sprintf (str,  "FMUL.R64", DIS_MEM64);
26425 
26426                                       
26427 
26428                                       
26429                                       
26430                                       
26431                                     }
26432                                     
26433                                     break;
26434                                   case 4: 
26435                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
26436                                     if ((MATCH_w_8_16 & 0x7) 
26437                                             /* base at 16 */ == 5 && 
26438                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26439                                             /* index at 16 */ && 
26440                                       (MATCH_w_8_16 >> 3 & 0x7) 
26441                                             /* index at 16 */ < 8)) 
26442                                       goto MATCH_label_a1055;  /*opt-block+*/
26443                                     else 
26444                                       goto MATCH_label_a1054;  /*opt-block+*/
26445                                     
26446                                     break;
26447                                   case 5: 
26448                                     goto MATCH_label_a1056; break;
26449                                   default: assert(0);
26450                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
26451                               break;
26452                             case 1: 
26453                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
26454                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
26455                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26456                                       /* index at 16 */ && 
26457                                 (MATCH_w_8_16 >> 3 & 0x7) 
26458                                       /* index at 16 */ < 8)) { 
26459                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
26460                                 nextPC = 4 + MATCH_p; 
26461                                 
26462                                 #line 1627 "machine/pentium/disassembler.m"
26463                                 
26464 
26465                                         sprintf (str,  "FMUL.R64", DIS_MEM64);
26466 
26467                                 
26468 
26469                                 
26470                                 
26471                                 
26472                               } /*opt-block*//*opt-block+*/
26473                               else 
26474                                 goto MATCH_label_a1054;  /*opt-block+*/
26475                               
26476                               break;
26477                             case 2: 
26478                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
26479                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
26480                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26481                                       /* index at 16 */ && 
26482                                 (MATCH_w_8_16 >> 3 & 0x7) 
26483                                       /* index at 16 */ < 8)) 
26484                                 goto MATCH_label_a1055;  /*opt-block+*/
26485                               else 
26486                                 goto MATCH_label_a1056;  /*opt-block+*/
26487                               
26488                               break;
26489                             case 3: 
26490                               { 
26491                                 unsigned idx = 
26492                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
26493                                 nextPC = 2 + MATCH_p; 
26494                                 
26495                                 #line 1633 "machine/pentium/disassembler.m"
26496                                 
26497 
26498                                         sprintf (str,  "FMUL.STi.ST", DIS_IDX);
26499 
26500                                 
26501 
26502                                 
26503                                 
26504                                 
26505                               }
26506                               
26507                               break;
26508                             default: assert(0);
26509                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
26510                         break;
26511                       case 2: 
26512                         
26513                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
26514                             case 0: 
26515                               
26516                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
26517                                   case 0: case 1: case 2: case 3: case 6: 
26518                                   case 7: 
26519                                     { 
26520                                       unsigned Mem64 = 
26521                                         1 + addressToPC(MATCH_p);
26522                                       nextPC = 2 + MATCH_p; 
26523                                       
26524                                       #line 1466 "machine/pentium/disassembler.m"
26525                                       
26526 
26527                                               sprintf (str,  "FCOM.R64", DIS_MEM64);
26528 
26529                                       
26530 
26531                                       
26532                                       
26533                                       
26534                                     }
26535                                     
26536                                     break;
26537                                   case 4: 
26538                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
26539                                     if ((MATCH_w_8_16 & 0x7) 
26540                                             /* base at 16 */ == 5 && 
26541                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26542                                             /* index at 16 */ && 
26543                                       (MATCH_w_8_16 >> 3 & 0x7) 
26544                                             /* index at 16 */ < 8)) 
26545                                       goto MATCH_label_a1058;  /*opt-block+*/
26546                                     else 
26547                                       goto MATCH_label_a1057;  /*opt-block+*/
26548                                     
26549                                     break;
26550                                   case 5: 
26551                                     goto MATCH_label_a1059; break;
26552                                   default: assert(0);
26553                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
26554                               break;
26555                             case 1: 
26556                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
26557                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
26558                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26559                                       /* index at 16 */ && 
26560                                 (MATCH_w_8_16 >> 3 & 0x7) 
26561                                       /* index at 16 */ < 8)) { 
26562                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
26563                                 nextPC = 4 + MATCH_p; 
26564                                 
26565                                 #line 1466 "machine/pentium/disassembler.m"
26566                                 
26567 
26568                                         sprintf (str,  "FCOM.R64", DIS_MEM64);
26569 
26570                                 
26571 
26572                                 
26573                                 
26574                                 
26575                               } /*opt-block*//*opt-block+*/
26576                               else 
26577                                 goto MATCH_label_a1057;  /*opt-block+*/
26578                               
26579                               break;
26580                             case 2: 
26581                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
26582                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
26583                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26584                                       /* index at 16 */ && 
26585                                 (MATCH_w_8_16 >> 3 & 0x7) 
26586                                       /* index at 16 */ < 8)) 
26587                                 goto MATCH_label_a1058;  /*opt-block+*/
26588                               else 
26589                                 goto MATCH_label_a1059;  /*opt-block+*/
26590                               
26591                               break;
26592                             case 3: 
26593                               goto MATCH_label_a39; break;
26594                             default: assert(0);
26595                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
26596                         break;
26597                       case 3: 
26598                         
26599                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
26600                             case 0: 
26601                               
26602                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
26603                                   case 0: case 1: case 2: case 3: case 6: 
26604                                   case 7: 
26605                                     { 
26606                                       unsigned Mem64 = 
26607                                         1 + addressToPC(MATCH_p);
26608                                       nextPC = 2 + MATCH_p; 
26609                                       
26610                                       #line 1478 "machine/pentium/disassembler.m"
26611                                       
26612 
26613                                               sprintf (str,  "FCOMP.R64", DIS_MEM64);
26614 
26615                                       
26616 
26617                                       
26618                                       
26619                                       
26620                                     }
26621                                     
26622                                     break;
26623                                   case 4: 
26624                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
26625                                     if ((MATCH_w_8_16 & 0x7) 
26626                                             /* base at 16 */ == 5 && 
26627                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26628                                             /* index at 16 */ && 
26629                                       (MATCH_w_8_16 >> 3 & 0x7) 
26630                                             /* index at 16 */ < 8)) 
26631                                       goto MATCH_label_a1061;  /*opt-block+*/
26632                                     else 
26633                                       goto MATCH_label_a1060;  /*opt-block+*/
26634                                     
26635                                     break;
26636                                   case 5: 
26637                                     goto MATCH_label_a1062; break;
26638                                   default: assert(0);
26639                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
26640                               break;
26641                             case 1: 
26642                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
26643                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
26644                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26645                                       /* index at 16 */ && 
26646                                 (MATCH_w_8_16 >> 3 & 0x7) 
26647                                       /* index at 16 */ < 8)) { 
26648                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
26649                                 nextPC = 4 + MATCH_p; 
26650                                 
26651                                 #line 1478 "machine/pentium/disassembler.m"
26652                                 
26653 
26654                                         sprintf (str,  "FCOMP.R64", DIS_MEM64);
26655 
26656                                 
26657 
26658                                 
26659                                 
26660                                 
26661                               } /*opt-block*//*opt-block+*/
26662                               else 
26663                                 goto MATCH_label_a1060;  /*opt-block+*/
26664                               
26665                               break;
26666                             case 2: 
26667                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
26668                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
26669                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26670                                       /* index at 16 */ && 
26671                                 (MATCH_w_8_16 >> 3 & 0x7) 
26672                                       /* index at 16 */ < 8)) 
26673                                 goto MATCH_label_a1061;  /*opt-block+*/
26674                               else 
26675                                 goto MATCH_label_a1062;  /*opt-block+*/
26676                               
26677                               break;
26678                             case 3: 
26679                               goto MATCH_label_a39; break;
26680                             default: assert(0);
26681                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
26682                         break;
26683                       case 4: 
26684                         
26685                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
26686                             case 0: 
26687                               
26688                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
26689                                   case 0: case 1: case 2: case 3: case 6: 
26690                                   case 7: 
26691                                     { 
26692                                       unsigned Mem64 = 
26693                                         1 + addressToPC(MATCH_p);
26694                                       nextPC = 2 + MATCH_p; 
26695                                       
26696                                       #line 1717 "machine/pentium/disassembler.m"
26697                                       
26698 
26699                                               sprintf (str,  "FSUB.R64", DIS_MEM64);
26700 
26701                                       
26702 
26703                                       
26704                                       
26705                                       
26706                                     }
26707                                     
26708                                     break;
26709                                   case 4: 
26710                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
26711                                     if ((MATCH_w_8_16 & 0x7) 
26712                                             /* base at 16 */ == 5 && 
26713                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26714                                             /* index at 16 */ && 
26715                                       (MATCH_w_8_16 >> 3 & 0x7) 
26716                                             /* index at 16 */ < 8)) 
26717                                       goto MATCH_label_a1064;  /*opt-block+*/
26718                                     else 
26719                                       goto MATCH_label_a1063;  /*opt-block+*/
26720                                     
26721                                     break;
26722                                   case 5: 
26723                                     goto MATCH_label_a1065; break;
26724                                   default: assert(0);
26725                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
26726                               break;
26727                             case 1: 
26728                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
26729                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
26730                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26731                                       /* index at 16 */ && 
26732                                 (MATCH_w_8_16 >> 3 & 0x7) 
26733                                       /* index at 16 */ < 8)) { 
26734                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
26735                                 nextPC = 4 + MATCH_p; 
26736                                 
26737                                 #line 1717 "machine/pentium/disassembler.m"
26738                                 
26739 
26740                                         sprintf (str,  "FSUB.R64", DIS_MEM64);
26741 
26742                                 
26743 
26744                                 
26745                                 
26746                                 
26747                               } /*opt-block*//*opt-block+*/
26748                               else 
26749                                 goto MATCH_label_a1063;  /*opt-block+*/
26750                               
26751                               break;
26752                             case 2: 
26753                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
26754                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
26755                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26756                                       /* index at 16 */ && 
26757                                 (MATCH_w_8_16 >> 3 & 0x7) 
26758                                       /* index at 16 */ < 8)) 
26759                                 goto MATCH_label_a1064;  /*opt-block+*/
26760                               else 
26761                                 goto MATCH_label_a1065;  /*opt-block+*/
26762                               
26763                               break;
26764                             case 3: 
26765                               { 
26766                                 unsigned idx = 
26767                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
26768                                 nextPC = 2 + MATCH_p; 
26769                                 
26770                                 #line 1723 "machine/pentium/disassembler.m"
26771                                 
26772 
26773                                         sprintf (str,  "FSUB.STi.ST", DIS_IDX);
26774 
26775                                 
26776 
26777                                 
26778                                 
26779                                 
26780                               }
26781                               
26782                               break;
26783                             default: assert(0);
26784                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
26785                         break;
26786                       case 5: 
26787                         
26788                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
26789                             case 0: 
26790                               
26791                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
26792                                   case 0: case 1: case 2: case 3: case 6: 
26793                                   case 7: 
26794                                     { 
26795                                       unsigned Mem64 = 
26796                                         1 + addressToPC(MATCH_p);
26797                                       nextPC = 2 + MATCH_p; 
26798                                       
26799                                       #line 1738 "machine/pentium/disassembler.m"
26800                                       
26801 
26802                                               sprintf (str,  "FSUBR.R64", DIS_MEM64);
26803 
26804                                       
26805 
26806                                       
26807                                       
26808                                       
26809                                     }
26810                                     
26811                                     break;
26812                                   case 4: 
26813                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
26814                                     if ((MATCH_w_8_16 & 0x7) 
26815                                             /* base at 16 */ == 5 && 
26816                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26817                                             /* index at 16 */ && 
26818                                       (MATCH_w_8_16 >> 3 & 0x7) 
26819                                             /* index at 16 */ < 8)) 
26820                                       goto MATCH_label_a1067;  /*opt-block+*/
26821                                     else 
26822                                       goto MATCH_label_a1066;  /*opt-block+*/
26823                                     
26824                                     break;
26825                                   case 5: 
26826                                     goto MATCH_label_a1068; break;
26827                                   default: assert(0);
26828                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
26829                               break;
26830                             case 1: 
26831                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
26832                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
26833                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26834                                       /* index at 16 */ && 
26835                                 (MATCH_w_8_16 >> 3 & 0x7) 
26836                                       /* index at 16 */ < 8)) { 
26837                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
26838                                 nextPC = 4 + MATCH_p; 
26839                                 
26840                                 #line 1738 "machine/pentium/disassembler.m"
26841                                 
26842 
26843                                         sprintf (str,  "FSUBR.R64", DIS_MEM64);
26844 
26845                                 
26846 
26847                                 
26848                                 
26849                                 
26850                               } /*opt-block*//*opt-block+*/
26851                               else 
26852                                 goto MATCH_label_a1066;  /*opt-block+*/
26853                               
26854                               break;
26855                             case 2: 
26856                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
26857                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
26858                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26859                                       /* index at 16 */ && 
26860                                 (MATCH_w_8_16 >> 3 & 0x7) 
26861                                       /* index at 16 */ < 8)) 
26862                                 goto MATCH_label_a1067;  /*opt-block+*/
26863                               else 
26864                                 goto MATCH_label_a1068;  /*opt-block+*/
26865                               
26866                               break;
26867                             case 3: 
26868                               { 
26869                                 unsigned idx = 
26870                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
26871                                 nextPC = 2 + MATCH_p; 
26872                                 
26873                                 #line 1744 "machine/pentium/disassembler.m"
26874                                 
26875 
26876                                         sprintf (str,  "FSUBR.STi.ST", DIS_IDX);
26877 
26878                                 
26879 
26880                                 
26881                                 
26882                                 
26883                               }
26884                               
26885                               break;
26886                             default: assert(0);
26887                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
26888                         break;
26889                       case 6: 
26890                         
26891                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
26892                             case 0: 
26893                               
26894                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
26895                                   case 0: case 1: case 2: case 3: case 6: 
26896                                   case 7: 
26897                                     { 
26898                                       unsigned Mem64 = 
26899                                         1 + addressToPC(MATCH_p);
26900                                       nextPC = 2 + MATCH_p; 
26901                                       
26902                                       #line 1511 "machine/pentium/disassembler.m"
26903                                       
26904 
26905                                               sprintf (str,  "FDIV.R64", DIS_MEM64);
26906 
26907                                       
26908 
26909                                       
26910                                       
26911                                       
26912                                     }
26913                                     
26914                                     break;
26915                                   case 4: 
26916                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
26917                                     if ((MATCH_w_8_16 & 0x7) 
26918                                             /* base at 16 */ == 5 && 
26919                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26920                                             /* index at 16 */ && 
26921                                       (MATCH_w_8_16 >> 3 & 0x7) 
26922                                             /* index at 16 */ < 8)) 
26923                                       goto MATCH_label_a1070;  /*opt-block+*/
26924                                     else 
26925                                       goto MATCH_label_a1069;  /*opt-block+*/
26926                                     
26927                                     break;
26928                                   case 5: 
26929                                     goto MATCH_label_a1071; break;
26930                                   default: assert(0);
26931                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
26932                               break;
26933                             case 1: 
26934                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
26935                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
26936                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26937                                       /* index at 16 */ && 
26938                                 (MATCH_w_8_16 >> 3 & 0x7) 
26939                                       /* index at 16 */ < 8)) { 
26940                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
26941                                 nextPC = 4 + MATCH_p; 
26942                                 
26943                                 #line 1511 "machine/pentium/disassembler.m"
26944                                 
26945 
26946                                         sprintf (str,  "FDIV.R64", DIS_MEM64);
26947 
26948                                 
26949 
26950                                 
26951                                 
26952                                 
26953                               } /*opt-block*//*opt-block+*/
26954                               else 
26955                                 goto MATCH_label_a1069;  /*opt-block+*/
26956                               
26957                               break;
26958                             case 2: 
26959                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
26960                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
26961                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
26962                                       /* index at 16 */ && 
26963                                 (MATCH_w_8_16 >> 3 & 0x7) 
26964                                       /* index at 16 */ < 8)) 
26965                                 goto MATCH_label_a1070;  /*opt-block+*/
26966                               else 
26967                                 goto MATCH_label_a1071;  /*opt-block+*/
26968                               
26969                               break;
26970                             case 3: 
26971                               { 
26972                                 unsigned idx = 
26973                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
26974                                 nextPC = 2 + MATCH_p; 
26975                                 
26976                                 #line 1517 "machine/pentium/disassembler.m"
26977                                 
26978 
26979                                         sprintf (str,  "FDIV.STi.ST", DIS_IDX);
26980 
26981                                 
26982 
26983                                 
26984                                 
26985                                 
26986                               }
26987                               
26988                               break;
26989                             default: assert(0);
26990                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
26991                         break;
26992                       case 7: 
26993                         
26994                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
26995                             case 0: 
26996                               
26997                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
26998                                   case 0: case 1: case 2: case 3: case 6: 
26999                                   case 7: 
27000                                     { 
27001                                       unsigned Mem64 = 
27002                                         1 + addressToPC(MATCH_p);
27003                                       nextPC = 2 + MATCH_p; 
27004                                       
27005                                       #line 1532 "machine/pentium/disassembler.m"
27006                                       
27007 
27008                                               sprintf (str,  "FDIVR.R64", DIS_MEM64);
27009 
27010                                       
27011 
27012                                       
27013                                       
27014                                       
27015                                     }
27016                                     
27017                                     break;
27018                                   case 4: 
27019                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27020                                     if ((MATCH_w_8_16 & 0x7) 
27021                                             /* base at 16 */ == 5 && 
27022                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27023                                             /* index at 16 */ && 
27024                                       (MATCH_w_8_16 >> 3 & 0x7) 
27025                                             /* index at 16 */ < 8)) 
27026                                       goto MATCH_label_a1073;  /*opt-block+*/
27027                                     else 
27028                                       goto MATCH_label_a1072;  /*opt-block+*/
27029                                     
27030                                     break;
27031                                   case 5: 
27032                                     goto MATCH_label_a1074; break;
27033                                   default: assert(0);
27034                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
27035                               break;
27036                             case 1: 
27037                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27038                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27039                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27040                                       /* index at 16 */ && 
27041                                 (MATCH_w_8_16 >> 3 & 0x7) 
27042                                       /* index at 16 */ < 8)) { 
27043                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
27044                                 nextPC = 4 + MATCH_p; 
27045                                 
27046                                 #line 1532 "machine/pentium/disassembler.m"
27047                                 
27048 
27049                                         sprintf (str,  "FDIVR.R64", DIS_MEM64);
27050 
27051                                 
27052 
27053                                 
27054                                 
27055                                 
27056                               } /*opt-block*//*opt-block+*/
27057                               else 
27058                                 goto MATCH_label_a1072;  /*opt-block+*/
27059                               
27060                               break;
27061                             case 2: 
27062                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27063                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27064                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27065                                       /* index at 16 */ && 
27066                                 (MATCH_w_8_16 >> 3 & 0x7) 
27067                                       /* index at 16 */ < 8)) 
27068                                 goto MATCH_label_a1073;  /*opt-block+*/
27069                               else 
27070                                 goto MATCH_label_a1074;  /*opt-block+*/
27071                               
27072                               break;
27073                             case 3: 
27074                               { 
27075                                 unsigned idx = 
27076                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
27077                                 nextPC = 2 + MATCH_p; 
27078                                 
27079                                 #line 1538 "machine/pentium/disassembler.m"
27080                                 
27081 
27082                                         sprintf (str,  "FDIVR.STi.ST", DIS_IDX);
27083 
27084                                 
27085 
27086                                 
27087                                 
27088                                 
27089                               }
27090                               
27091                               break;
27092                             default: assert(0);
27093                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
27094                         break;
27095                       default: assert(0);
27096                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
27097                   
27098                   break;
27099                 case 5: 
27100                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
27101                   
27102                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
27103                       case 0: 
27104                         
27105                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
27106                             case 0: 
27107                               
27108                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
27109                                   case 0: case 1: case 2: case 3: case 6: 
27110                                   case 7: 
27111                                     { 
27112                                       unsigned Mem64 = 
27113                                         1 + addressToPC(MATCH_p);
27114                                       nextPC = 2 + MATCH_p; 
27115                                       
27116                                       #line 1583 "machine/pentium/disassembler.m"
27117                                       
27118 
27119                                               sprintf (str,  "FLD.lsR64", DIS_MEM64);
27120 
27121                                       
27122 
27123                                       
27124                                       
27125                                       
27126                                     }
27127                                     
27128                                     break;
27129                                   case 4: 
27130                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27131                                     if ((MATCH_w_8_16 & 0x7) 
27132                                             /* base at 16 */ == 5 && 
27133                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27134                                             /* index at 16 */ && 
27135                                       (MATCH_w_8_16 >> 3 & 0x7) 
27136                                             /* index at 16 */ < 8)) 
27137                                       goto MATCH_label_a1076;  /*opt-block+*/
27138                                     else 
27139                                       goto MATCH_label_a1075;  /*opt-block+*/
27140                                     
27141                                     break;
27142                                   case 5: 
27143                                     goto MATCH_label_a1077; break;
27144                                   default: assert(0);
27145                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
27146                               break;
27147                             case 1: 
27148                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27149                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27150                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27151                                       /* index at 16 */ && 
27152                                 (MATCH_w_8_16 >> 3 & 0x7) 
27153                                       /* index at 16 */ < 8)) { 
27154                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
27155                                 nextPC = 4 + MATCH_p; 
27156                                 
27157                                 #line 1583 "machine/pentium/disassembler.m"
27158                                 
27159 
27160                                         sprintf (str,  "FLD.lsR64", DIS_MEM64);
27161 
27162                                 
27163 
27164                                 
27165                                 
27166                                 
27167                               } /*opt-block*//*opt-block+*/
27168                               else 
27169                                 goto MATCH_label_a1075;  /*opt-block+*/
27170                               
27171                               break;
27172                             case 2: 
27173                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27174                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27175                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27176                                       /* index at 16 */ && 
27177                                 (MATCH_w_8_16 >> 3 & 0x7) 
27178                                       /* index at 16 */ < 8)) 
27179                                 goto MATCH_label_a1076;  /*opt-block+*/
27180                               else 
27181                                 goto MATCH_label_a1077;  /*opt-block+*/
27182                               
27183                               break;
27184                             case 3: 
27185                               { 
27186                                 unsigned idx = 
27187                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
27188                                 nextPC = 2 + MATCH_p; 
27189                                 
27190                                 #line 1550 "machine/pentium/disassembler.m"
27191                                 
27192 
27193                                         sprintf (str,  "FFREE", DIS_IDX);
27194 
27195                                 
27196 
27197                                 
27198                                 
27199                                 
27200                               }
27201                               
27202                               break;
27203                             default: assert(0);
27204                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
27205                         break;
27206                       case 1: 
27207                         goto MATCH_label_a39; break;
27208                       case 2: 
27209                         
27210                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
27211                             case 0: 
27212                               
27213                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
27214                                   case 0: case 1: case 2: case 3: case 6: 
27215                                   case 7: 
27216                                     { 
27217                                       unsigned Mem64 = 
27218                                         1 + addressToPC(MATCH_p);
27219                                       nextPC = 2 + MATCH_p; 
27220                                       
27221                                       #line 1684 "machine/pentium/disassembler.m"
27222                                       
27223 
27224                                               sprintf (str,  "FST.lsR64", DIS_MEM64);
27225 
27226                                       
27227 
27228                                       
27229                                       
27230                                       
27231                                     }
27232                                     
27233                                     break;
27234                                   case 4: 
27235                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27236                                     if ((MATCH_w_8_16 & 0x7) 
27237                                             /* base at 16 */ == 5 && 
27238                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27239                                             /* index at 16 */ && 
27240                                       (MATCH_w_8_16 >> 3 & 0x7) 
27241                                             /* index at 16 */ < 8)) 
27242                                       goto MATCH_label_a1079;  /*opt-block+*/
27243                                     else 
27244                                       goto MATCH_label_a1078;  /*opt-block+*/
27245                                     
27246                                     break;
27247                                   case 5: 
27248                                     goto MATCH_label_a1080; break;
27249                                   default: assert(0);
27250                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
27251                               break;
27252                             case 1: 
27253                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27254                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27255                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27256                                       /* index at 16 */ && 
27257                                 (MATCH_w_8_16 >> 3 & 0x7) 
27258                                       /* index at 16 */ < 8)) { 
27259                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
27260                                 nextPC = 4 + MATCH_p; 
27261                                 
27262                                 #line 1684 "machine/pentium/disassembler.m"
27263                                 
27264 
27265                                         sprintf (str,  "FST.lsR64", DIS_MEM64);
27266 
27267                                 
27268 
27269                                 
27270                                 
27271                                 
27272                               } /*opt-block*//*opt-block+*/
27273                               else 
27274                                 goto MATCH_label_a1078;  /*opt-block+*/
27275                               
27276                               break;
27277                             case 2: 
27278                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27279                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27280                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27281                                       /* index at 16 */ && 
27282                                 (MATCH_w_8_16 >> 3 & 0x7) 
27283                                       /* index at 16 */ < 8)) 
27284                                 goto MATCH_label_a1079;  /*opt-block+*/
27285                               else 
27286                                 goto MATCH_label_a1080;  /*opt-block+*/
27287                               
27288                               break;
27289                             case 3: 
27290                               { 
27291                                 unsigned idx = 
27292                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
27293                                 nextPC = 2 + MATCH_p; 
27294                                 
27295                                 #line 1696 "machine/pentium/disassembler.m"
27296                                 
27297 
27298                                         sprintf (str,  "FST.st.STi", DIS_IDX);
27299 
27300                                 
27301 
27302                                 
27303                                 
27304                                 
27305                               }
27306                               
27307                               break;
27308                             default: assert(0);
27309                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
27310                         break;
27311                       case 3: 
27312                         
27313                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
27314                             case 0: 
27315                               
27316                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
27317                                   case 0: case 1: case 2: case 3: case 6: 
27318                                   case 7: 
27319                                     { 
27320                                       unsigned Mem64 = 
27321                                         1 + addressToPC(MATCH_p);
27322                                       nextPC = 2 + MATCH_p; 
27323                                       
27324                                       #line 1690 "machine/pentium/disassembler.m"
27325                                       
27326 
27327                                               sprintf (str,  "FSTP.lsR64", DIS_MEM64);
27328 
27329                                       
27330 
27331                                       
27332                                       
27333                                       
27334                                     }
27335                                     
27336                                     break;
27337                                   case 4: 
27338                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27339                                     if ((MATCH_w_8_16 & 0x7) 
27340                                             /* base at 16 */ == 5 && 
27341                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27342                                             /* index at 16 */ && 
27343                                       (MATCH_w_8_16 >> 3 & 0x7) 
27344                                             /* index at 16 */ < 8)) 
27345                                       goto MATCH_label_a1082;  /*opt-block+*/
27346                                     else 
27347                                       goto MATCH_label_a1081;  /*opt-block+*/
27348                                     
27349                                     break;
27350                                   case 5: 
27351                                     goto MATCH_label_a1083; break;
27352                                   default: assert(0);
27353                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
27354                               break;
27355                             case 1: 
27356                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27357                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27358                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27359                                       /* index at 16 */ && 
27360                                 (MATCH_w_8_16 >> 3 & 0x7) 
27361                                       /* index at 16 */ < 8)) { 
27362                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
27363                                 nextPC = 4 + MATCH_p; 
27364                                 
27365                                 #line 1690 "machine/pentium/disassembler.m"
27366                                 
27367 
27368                                         sprintf (str,  "FSTP.lsR64", DIS_MEM64);
27369 
27370                                 
27371 
27372                                 
27373                                 
27374                                 
27375                               } /*opt-block*//*opt-block+*/
27376                               else 
27377                                 goto MATCH_label_a1081;  /*opt-block+*/
27378                               
27379                               break;
27380                             case 2: 
27381                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27382                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27383                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27384                                       /* index at 16 */ && 
27385                                 (MATCH_w_8_16 >> 3 & 0x7) 
27386                                       /* index at 16 */ < 8)) 
27387                                 goto MATCH_label_a1082;  /*opt-block+*/
27388                               else 
27389                                 goto MATCH_label_a1083;  /*opt-block+*/
27390                               
27391                               break;
27392                             case 3: 
27393                               { 
27394                                 unsigned idx = 
27395                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
27396                                 nextPC = 2 + MATCH_p; 
27397                                 
27398                                 #line 1699 "machine/pentium/disassembler.m"
27399                                 
27400 
27401                                         sprintf (str,  "FSTP.st.STi", DIS_IDX);
27402 
27403                                 
27404 
27405                                 
27406                                 
27407                                 
27408                               }
27409                               
27410                               break;
27411                             default: assert(0);
27412                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
27413                         break;
27414                       case 4: 
27415                         
27416                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
27417                             case 0: 
27418                               
27419                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
27420                                   case 0: case 1: case 2: case 3: case 6: 
27421                                   case 7: 
27422                                     { 
27423                                       unsigned Mem = 1 + addressToPC(MATCH_p);
27424                                       nextPC = 2 + MATCH_p; 
27425                                       
27426                                       #line 1663 "machine/pentium/disassembler.m"
27427                                       
27428 
27429                                               sprintf (str,  "FRSTOR", DIS_MEM);
27430 
27431                                       
27432 
27433                                       
27434                                       
27435                                       
27436                                     }
27437                                     
27438                                     break;
27439                                   case 4: 
27440                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27441                                     if ((MATCH_w_8_16 & 0x7) 
27442                                             /* base at 16 */ == 5 && 
27443                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27444                                             /* index at 16 */ && 
27445                                       (MATCH_w_8_16 >> 3 & 0x7) 
27446                                             /* index at 16 */ < 8)) 
27447                                       goto MATCH_label_a1085;  /*opt-block+*/
27448                                     else 
27449                                       goto MATCH_label_a1084;  /*opt-block+*/
27450                                     
27451                                     break;
27452                                   case 5: 
27453                                     goto MATCH_label_a1086; break;
27454                                   default: assert(0);
27455                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
27456                               break;
27457                             case 1: 
27458                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27459                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27460                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27461                                       /* index at 16 */ && 
27462                                 (MATCH_w_8_16 >> 3 & 0x7) 
27463                                       /* index at 16 */ < 8)) { 
27464                                 unsigned Mem = 1 + addressToPC(MATCH_p);
27465                                 nextPC = 4 + MATCH_p; 
27466                                 
27467                                 #line 1663 "machine/pentium/disassembler.m"
27468                                 
27469 
27470                                         sprintf (str,  "FRSTOR", DIS_MEM);
27471 
27472                                 
27473 
27474                                 
27475                                 
27476                                 
27477                               } /*opt-block*//*opt-block+*/
27478                               else 
27479                                 goto MATCH_label_a1084;  /*opt-block+*/
27480                               
27481                               break;
27482                             case 2: 
27483                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27484                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27485                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27486                                       /* index at 16 */ && 
27487                                 (MATCH_w_8_16 >> 3 & 0x7) 
27488                                       /* index at 16 */ < 8)) 
27489                                 goto MATCH_label_a1085;  /*opt-block+*/
27490                               else 
27491                                 goto MATCH_label_a1086;  /*opt-block+*/
27492                               
27493                               break;
27494                             case 3: 
27495                               { 
27496                                 unsigned idx = 
27497                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
27498                                 nextPC = 2 + MATCH_p; 
27499                                 
27500                                 #line 1759 "machine/pentium/disassembler.m"
27501                                 
27502 
27503                                         sprintf (str,  "FUCOM", DIS_IDX);
27504 
27505                                 
27506 
27507                                 
27508                                 
27509                                 
27510                               }
27511                               
27512                               break;
27513                             default: assert(0);
27514                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
27515                         break;
27516                       case 5: 
27517                         if ((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */ == 3) { 
27518                           unsigned idx = (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
27519                           nextPC = 2 + MATCH_p; 
27520                           
27521                           #line 1762 "machine/pentium/disassembler.m"
27522                           
27523 
27524                                   sprintf (str,  "FUCOMP", DIS_IDX);
27525 
27526                           
27527 
27528                           
27529                           
27530                           
27531                         } /*opt-block*//*opt-block+*/
27532                         else 
27533                           goto MATCH_label_a39;  /*opt-block+*/
27534                         
27535                         break;
27536                       case 6: 
27537                         
27538                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
27539                             case 0: 
27540                               
27541                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
27542                                   case 0: case 1: case 2: case 3: case 6: 
27543                                   case 7: 
27544                                     { 
27545                                       unsigned Mem = 1 + addressToPC(MATCH_p);
27546                                       nextPC = 2 + MATCH_p; 
27547                                       
27548                                       #line 1666 "machine/pentium/disassembler.m"
27549                                       
27550 
27551                                               sprintf (str,  "FNSAVE", DIS_MEM);
27552 
27553                                       
27554 
27555                                       
27556                                       
27557                                       
27558                                     }
27559                                     
27560                                     break;
27561                                   case 4: 
27562                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27563                                     if ((MATCH_w_8_16 & 0x7) 
27564                                             /* base at 16 */ == 5 && 
27565                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27566                                             /* index at 16 */ && 
27567                                       (MATCH_w_8_16 >> 3 & 0x7) 
27568                                             /* index at 16 */ < 8)) 
27569                                       goto MATCH_label_a1088;  /*opt-block+*/
27570                                     else 
27571                                       goto MATCH_label_a1087;  /*opt-block+*/
27572                                     
27573                                     break;
27574                                   case 5: 
27575                                     goto MATCH_label_a1089; break;
27576                                   default: assert(0);
27577                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
27578                               break;
27579                             case 1: 
27580                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27581                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27582                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27583                                       /* index at 16 */ && 
27584                                 (MATCH_w_8_16 >> 3 & 0x7) 
27585                                       /* index at 16 */ < 8)) { 
27586                                 unsigned Mem = 1 + addressToPC(MATCH_p);
27587                                 nextPC = 4 + MATCH_p; 
27588                                 
27589                                 #line 1666 "machine/pentium/disassembler.m"
27590                                 
27591 
27592                                         sprintf (str,  "FNSAVE", DIS_MEM);
27593 
27594                                 
27595 
27596                                 
27597                                 
27598                                 
27599                               } /*opt-block*//*opt-block+*/
27600                               else 
27601                                 goto MATCH_label_a1087;  /*opt-block+*/
27602                               
27603                               break;
27604                             case 2: 
27605                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27606                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27607                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27608                                       /* index at 16 */ && 
27609                                 (MATCH_w_8_16 >> 3 & 0x7) 
27610                                       /* index at 16 */ < 8)) 
27611                                 goto MATCH_label_a1088;  /*opt-block+*/
27612                               else 
27613                                 goto MATCH_label_a1089;  /*opt-block+*/
27614                               
27615                               break;
27616                             case 3: 
27617                               goto MATCH_label_a39; break;
27618                             default: assert(0);
27619                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
27620                         break;
27621                       case 7: 
27622                         
27623                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
27624                             case 0: 
27625                               
27626                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
27627                                   case 0: case 1: case 2: case 3: case 6: 
27628                                   case 7: 
27629                                     { 
27630                                       unsigned Mem16 = 
27631                                         1 + addressToPC(MATCH_p);
27632                                       nextPC = 2 + MATCH_p; 
27633                                       
27634                                       #line 1708 "machine/pentium/disassembler.m"
27635                                       
27636 
27637                                               sprintf (str,  "FSTSW", DIS_MEM16);
27638 
27639                                       
27640 
27641                                       
27642                                       
27643                                       
27644                                     }
27645                                     
27646                                     break;
27647                                   case 4: 
27648                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27649                                     if ((MATCH_w_8_16 & 0x7) 
27650                                             /* base at 16 */ == 5 && 
27651                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27652                                             /* index at 16 */ && 
27653                                       (MATCH_w_8_16 >> 3 & 0x7) 
27654                                             /* index at 16 */ < 8)) 
27655                                       goto MATCH_label_a1091;  /*opt-block+*/
27656                                     else 
27657                                       goto MATCH_label_a1090;  /*opt-block+*/
27658                                     
27659                                     break;
27660                                   case 5: 
27661                                     goto MATCH_label_a1092; break;
27662                                   default: assert(0);
27663                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
27664                               break;
27665                             case 1: 
27666                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27667                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27668                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27669                                       /* index at 16 */ && 
27670                                 (MATCH_w_8_16 >> 3 & 0x7) 
27671                                       /* index at 16 */ < 8)) { 
27672                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
27673                                 nextPC = 4 + MATCH_p; 
27674                                 
27675                                 #line 1708 "machine/pentium/disassembler.m"
27676                                 
27677 
27678                                         sprintf (str,  "FSTSW", DIS_MEM16);
27679 
27680                                 
27681 
27682                                 
27683                                 
27684                                 
27685                               } /*opt-block*//*opt-block+*/
27686                               else 
27687                                 goto MATCH_label_a1090;  /*opt-block+*/
27688                               
27689                               break;
27690                             case 2: 
27691                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27692                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27693                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27694                                       /* index at 16 */ && 
27695                                 (MATCH_w_8_16 >> 3 & 0x7) 
27696                                       /* index at 16 */ < 8)) 
27697                                 goto MATCH_label_a1091;  /*opt-block+*/
27698                               else 
27699                                 goto MATCH_label_a1092;  /*opt-block+*/
27700                               
27701                               break;
27702                             case 3: 
27703                               goto MATCH_label_a39; break;
27704                             default: assert(0);
27705                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
27706                         break;
27707                       default: assert(0);
27708                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
27709                   
27710                   break;
27711                 case 6: 
27712                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
27713                   
27714                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
27715                       case 0: 
27716                         
27717                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
27718                             case 0: 
27719                               
27720                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
27721                                   case 0: case 1: case 2: case 3: case 6: 
27722                                   case 7: 
27723                                     { 
27724                                       unsigned Mem16 = 
27725                                         1 + addressToPC(MATCH_p);
27726                                       nextPC = 2 + MATCH_p; 
27727                                       
27728                                       #line 1448 "machine/pentium/disassembler.m"
27729                                       
27730 
27731                                               sprintf (str,  "FIADD.I16", DIS_MEM16);
27732 
27733                                       
27734 
27735                                       
27736                                       
27737                                       
27738                                     }
27739                                     
27740                                     break;
27741                                   case 4: 
27742                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27743                                     if ((MATCH_w_8_16 & 0x7) 
27744                                             /* base at 16 */ == 5 && 
27745                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27746                                             /* index at 16 */ && 
27747                                       (MATCH_w_8_16 >> 3 & 0x7) 
27748                                             /* index at 16 */ < 8)) 
27749                                       goto MATCH_label_a1094;  /*opt-block+*/
27750                                     else 
27751                                       goto MATCH_label_a1093;  /*opt-block+*/
27752                                     
27753                                     break;
27754                                   case 5: 
27755                                     goto MATCH_label_a1095; break;
27756                                   default: assert(0);
27757                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
27758                               break;
27759                             case 1: 
27760                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27761                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27762                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27763                                       /* index at 16 */ && 
27764                                 (MATCH_w_8_16 >> 3 & 0x7) 
27765                                       /* index at 16 */ < 8)) { 
27766                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
27767                                 nextPC = 4 + MATCH_p; 
27768                                 
27769                                 #line 1448 "machine/pentium/disassembler.m"
27770                                 
27771 
27772                                         sprintf (str,  "FIADD.I16", DIS_MEM16);
27773 
27774                                 
27775 
27776                                 
27777                                 
27778                                 
27779                               } /*opt-block*//*opt-block+*/
27780                               else 
27781                                 goto MATCH_label_a1093;  /*opt-block+*/
27782                               
27783                               break;
27784                             case 2: 
27785                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27786                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27787                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27788                                       /* index at 16 */ && 
27789                                 (MATCH_w_8_16 >> 3 & 0x7) 
27790                                       /* index at 16 */ < 8)) 
27791                                 goto MATCH_label_a1094;  /*opt-block+*/
27792                               else 
27793                                 goto MATCH_label_a1095;  /*opt-block+*/
27794                               
27795                               break;
27796                             case 3: 
27797                               { 
27798                                 unsigned idx = 
27799                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
27800                                 nextPC = 2 + MATCH_p; 
27801                                 
27802                                 #line 1442 "machine/pentium/disassembler.m"
27803                                 
27804 
27805                                         sprintf (str,  "FADDP.STi.ST", DIS_IDX);
27806 
27807                                 
27808 
27809                                 
27810                                 
27811                                 
27812                               }
27813                               
27814                               break;
27815                             default: assert(0);
27816                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
27817                         break;
27818                       case 1: 
27819                         
27820                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
27821                             case 0: 
27822                               
27823                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
27824                                   case 0: case 1: case 2: case 3: case 6: 
27825                                   case 7: 
27826                                     { 
27827                                       unsigned Mem16 = 
27828                                         1 + addressToPC(MATCH_p);
27829                                       nextPC = 2 + MATCH_p; 
27830                                       
27831                                       #line 1642 "machine/pentium/disassembler.m"
27832                                       
27833 
27834                                               sprintf (str,  "FIMUL.I16", DIS_MEM16);
27835 
27836                                       
27837 
27838                                       
27839                                       
27840                                       
27841                                     }
27842                                     
27843                                     break;
27844                                   case 4: 
27845                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27846                                     if ((MATCH_w_8_16 & 0x7) 
27847                                             /* base at 16 */ == 5 && 
27848                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27849                                             /* index at 16 */ && 
27850                                       (MATCH_w_8_16 >> 3 & 0x7) 
27851                                             /* index at 16 */ < 8)) 
27852                                       goto MATCH_label_a1097;  /*opt-block+*/
27853                                     else 
27854                                       goto MATCH_label_a1096;  /*opt-block+*/
27855                                     
27856                                     break;
27857                                   case 5: 
27858                                     goto MATCH_label_a1098; break;
27859                                   default: assert(0);
27860                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
27861                               break;
27862                             case 1: 
27863                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27864                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27865                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27866                                       /* index at 16 */ && 
27867                                 (MATCH_w_8_16 >> 3 & 0x7) 
27868                                       /* index at 16 */ < 8)) { 
27869                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
27870                                 nextPC = 4 + MATCH_p; 
27871                                 
27872                                 #line 1642 "machine/pentium/disassembler.m"
27873                                 
27874 
27875                                         sprintf (str,  "FIMUL.I16", DIS_MEM16);
27876 
27877                                 
27878 
27879                                 
27880                                 
27881                                 
27882                               } /*opt-block*//*opt-block+*/
27883                               else 
27884                                 goto MATCH_label_a1096;  /*opt-block+*/
27885                               
27886                               break;
27887                             case 2: 
27888                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27889                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27890                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27891                                       /* index at 16 */ && 
27892                                 (MATCH_w_8_16 >> 3 & 0x7) 
27893                                       /* index at 16 */ < 8)) 
27894                                 goto MATCH_label_a1097;  /*opt-block+*/
27895                               else 
27896                                 goto MATCH_label_a1098;  /*opt-block+*/
27897                               
27898                               break;
27899                             case 3: 
27900                               { 
27901                                 unsigned idx = 
27902                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
27903                                 nextPC = 2 + MATCH_p; 
27904                                 
27905                                 #line 1636 "machine/pentium/disassembler.m"
27906                                 
27907 
27908                                         sprintf (str,  "FMULP.STi.ST", DIS_IDX);
27909 
27910                                 
27911 
27912                                 
27913                                 
27914                                 
27915                               }
27916                               
27917                               break;
27918                             default: assert(0);
27919                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
27920                         break;
27921                       case 2: 
27922                         
27923                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
27924                             case 0: 
27925                               
27926                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
27927                                   case 0: case 1: case 2: case 3: case 6: 
27928                                   case 7: 
27929                                     { 
27930                                       unsigned Mem16 = 
27931                                         1 + addressToPC(MATCH_p);
27932                                       nextPC = 2 + MATCH_p; 
27933                                       
27934                                       #line 1472 "machine/pentium/disassembler.m"
27935                                       
27936 
27937                                               sprintf (str,  "FICOM.I16", DIS_MEM16);
27938 
27939                                       
27940 
27941                                       
27942                                       
27943                                       
27944                                     }
27945                                     
27946                                     break;
27947                                   case 4: 
27948                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
27949                                     if ((MATCH_w_8_16 & 0x7) 
27950                                             /* base at 16 */ == 5 && 
27951                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27952                                             /* index at 16 */ && 
27953                                       (MATCH_w_8_16 >> 3 & 0x7) 
27954                                             /* index at 16 */ < 8)) 
27955                                       goto MATCH_label_a1100;  /*opt-block+*/
27956                                     else 
27957                                       goto MATCH_label_a1099;  /*opt-block+*/
27958                                     
27959                                     break;
27960                                   case 5: 
27961                                     goto MATCH_label_a1101; break;
27962                                   default: assert(0);
27963                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
27964                               break;
27965                             case 1: 
27966                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27967                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27968                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27969                                       /* index at 16 */ && 
27970                                 (MATCH_w_8_16 >> 3 & 0x7) 
27971                                       /* index at 16 */ < 8)) { 
27972                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
27973                                 nextPC = 4 + MATCH_p; 
27974                                 
27975                                 #line 1472 "machine/pentium/disassembler.m"
27976                                 
27977 
27978                                         sprintf (str,  "FICOM.I16", DIS_MEM16);
27979 
27980                                 
27981 
27982                                 
27983                                 
27984                                 
27985                               } /*opt-block*//*opt-block+*/
27986                               else 
27987                                 goto MATCH_label_a1099;  /*opt-block+*/
27988                               
27989                               break;
27990                             case 2: 
27991                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
27992                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
27993                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
27994                                       /* index at 16 */ && 
27995                                 (MATCH_w_8_16 >> 3 & 0x7) 
27996                                       /* index at 16 */ < 8)) 
27997                                 goto MATCH_label_a1100;  /*opt-block+*/
27998                               else 
27999                                 goto MATCH_label_a1101;  /*opt-block+*/
28000                               
28001                               break;
28002                             case 3: 
28003                               goto MATCH_label_a39; break;
28004                             default: assert(0);
28005                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28006                         break;
28007                       case 3: 
28008                         
28009                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28010                             case 0: 
28011                               
28012                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28013                                   case 0: case 1: case 2: case 3: case 6: 
28014                                   case 7: 
28015                                     { 
28016                                       unsigned Mem16 = 
28017                                         1 + addressToPC(MATCH_p);
28018                                       nextPC = 2 + MATCH_p; 
28019                                       
28020                                       #line 1490 "machine/pentium/disassembler.m"
28021                                       
28022 
28023                                               sprintf (str,  "FICOMP.I16", DIS_MEM16);
28024 
28025                                       
28026 
28027                                       
28028                                       
28029                                       
28030                                     }
28031                                     
28032                                     break;
28033                                   case 4: 
28034                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28035                                     if ((MATCH_w_8_16 & 0x7) 
28036                                             /* base at 16 */ == 5 && 
28037                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28038                                             /* index at 16 */ && 
28039                                       (MATCH_w_8_16 >> 3 & 0x7) 
28040                                             /* index at 16 */ < 8)) 
28041                                       goto MATCH_label_a1103;  /*opt-block+*/
28042                                     else 
28043                                       goto MATCH_label_a1102;  /*opt-block+*/
28044                                     
28045                                     break;
28046                                   case 5: 
28047                                     goto MATCH_label_a1104; break;
28048                                   default: assert(0);
28049                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28050                               break;
28051                             case 1: 
28052                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28053                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28054                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28055                                       /* index at 16 */ && 
28056                                 (MATCH_w_8_16 >> 3 & 0x7) 
28057                                       /* index at 16 */ < 8)) { 
28058                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
28059                                 nextPC = 4 + MATCH_p; 
28060                                 
28061                                 #line 1490 "machine/pentium/disassembler.m"
28062                                 
28063 
28064                                         sprintf (str,  "FICOMP.I16", DIS_MEM16);
28065 
28066                                 
28067 
28068                                 
28069                                 
28070                                 
28071                               } /*opt-block*//*opt-block+*/
28072                               else 
28073                                 goto MATCH_label_a1102;  /*opt-block+*/
28074                               
28075                               break;
28076                             case 2: 
28077                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28078                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28079                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28080                                       /* index at 16 */ && 
28081                                 (MATCH_w_8_16 >> 3 & 0x7) 
28082                                       /* index at 16 */ < 8)) 
28083                                 goto MATCH_label_a1103;  /*opt-block+*/
28084                               else 
28085                                 goto MATCH_label_a1104;  /*opt-block+*/
28086                               
28087                               break;
28088                             case 3: 
28089                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 1) { 
28090                                 nextPC = 2 + MATCH_p; 
28091                                 
28092                                 #line 1493 "machine/pentium/disassembler.m"
28093                                 
28094 
28095                                         sprintf (str,  "FCOMPP");
28096 
28097                                 
28098 
28099                                 
28100                                 
28101                                 
28102                               } /*opt-block*//*opt-block+*/
28103                               else 
28104                                 goto MATCH_label_a39;  /*opt-block+*/
28105                               
28106                               break;
28107                             default: assert(0);
28108                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28109                         break;
28110                       case 4: 
28111                         
28112                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28113                             case 0: 
28114                               
28115                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28116                                   case 0: case 1: case 2: case 3: case 6: 
28117                                   case 7: 
28118                                     { 
28119                                       unsigned Mem16 = 
28120                                         1 + addressToPC(MATCH_p);
28121                                       nextPC = 2 + MATCH_p; 
28122                                       
28123                                       #line 1729 "machine/pentium/disassembler.m"
28124                                       
28125 
28126                                               sprintf (str,  "FISUB.I16", DIS_MEM16);
28127 
28128                                       
28129 
28130                                       
28131                                       
28132                                       
28133                                     }
28134                                     
28135                                     break;
28136                                   case 4: 
28137                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28138                                     if ((MATCH_w_8_16 & 0x7) 
28139                                             /* base at 16 */ == 5 && 
28140                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28141                                             /* index at 16 */ && 
28142                                       (MATCH_w_8_16 >> 3 & 0x7) 
28143                                             /* index at 16 */ < 8)) 
28144                                       goto MATCH_label_a1106;  /*opt-block+*/
28145                                     else 
28146                                       goto MATCH_label_a1105;  /*opt-block+*/
28147                                     
28148                                     break;
28149                                   case 5: 
28150                                     goto MATCH_label_a1107; break;
28151                                   default: assert(0);
28152                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28153                               break;
28154                             case 1: 
28155                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28156                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28157                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28158                                       /* index at 16 */ && 
28159                                 (MATCH_w_8_16 >> 3 & 0x7) 
28160                                       /* index at 16 */ < 8)) { 
28161                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
28162                                 nextPC = 4 + MATCH_p; 
28163                                 
28164                                 #line 1729 "machine/pentium/disassembler.m"
28165                                 
28166 
28167                                         sprintf (str,  "FISUB.I16", DIS_MEM16);
28168 
28169                                 
28170 
28171                                 
28172                                 
28173                                 
28174                               } /*opt-block*//*opt-block+*/
28175                               else 
28176                                 goto MATCH_label_a1105;  /*opt-block+*/
28177                               
28178                               break;
28179                             case 2: 
28180                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28181                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28182                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28183                                       /* index at 16 */ && 
28184                                 (MATCH_w_8_16 >> 3 & 0x7) 
28185                                       /* index at 16 */ < 8)) 
28186                                 goto MATCH_label_a1106;  /*opt-block+*/
28187                               else 
28188                                 goto MATCH_label_a1107;  /*opt-block+*/
28189                               
28190                               break;
28191                             case 3: 
28192                               { 
28193                                 unsigned idx = 
28194                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
28195                                 nextPC = 2 + MATCH_p; 
28196                                 
28197                                 #line 1732 "machine/pentium/disassembler.m"
28198                                 
28199 
28200                                         sprintf (str,  "FSUBP.STi.ST", DIS_IDX);
28201 
28202                                 
28203 
28204                                 
28205                                 
28206                                 
28207                               }
28208                               
28209                               break;
28210                             default: assert(0);
28211                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28212                         break;
28213                       case 5: 
28214                         
28215                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28216                             case 0: 
28217                               
28218                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28219                                   case 0: case 1: case 2: case 3: case 6: 
28220                                   case 7: 
28221                                     { 
28222                                       unsigned Mem16 = 
28223                                         1 + addressToPC(MATCH_p);
28224                                       nextPC = 2 + MATCH_p; 
28225                                       
28226                                       #line 1750 "machine/pentium/disassembler.m"
28227                                       
28228 
28229                                               sprintf (str,  "FISUBR.I16", DIS_MEM16);
28230 
28231                                       
28232 
28233                                       
28234                                       
28235                                       
28236                                     }
28237                                     
28238                                     break;
28239                                   case 4: 
28240                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28241                                     if ((MATCH_w_8_16 & 0x7) 
28242                                             /* base at 16 */ == 5 && 
28243                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28244                                             /* index at 16 */ && 
28245                                       (MATCH_w_8_16 >> 3 & 0x7) 
28246                                             /* index at 16 */ < 8)) 
28247                                       goto MATCH_label_a1109;  /*opt-block+*/
28248                                     else 
28249                                       goto MATCH_label_a1108;  /*opt-block+*/
28250                                     
28251                                     break;
28252                                   case 5: 
28253                                     goto MATCH_label_a1110; break;
28254                                   default: assert(0);
28255                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28256                               break;
28257                             case 1: 
28258                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28259                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28260                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28261                                       /* index at 16 */ && 
28262                                 (MATCH_w_8_16 >> 3 & 0x7) 
28263                                       /* index at 16 */ < 8)) { 
28264                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
28265                                 nextPC = 4 + MATCH_p; 
28266                                 
28267                                 #line 1750 "machine/pentium/disassembler.m"
28268                                 
28269 
28270                                         sprintf (str,  "FISUBR.I16", DIS_MEM16);
28271 
28272                                 
28273 
28274                                 
28275                                 
28276                                 
28277                               } /*opt-block*//*opt-block+*/
28278                               else 
28279                                 goto MATCH_label_a1108;  /*opt-block+*/
28280                               
28281                               break;
28282                             case 2: 
28283                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28284                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28285                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28286                                       /* index at 16 */ && 
28287                                 (MATCH_w_8_16 >> 3 & 0x7) 
28288                                       /* index at 16 */ < 8)) 
28289                                 goto MATCH_label_a1109;  /*opt-block+*/
28290                               else 
28291                                 goto MATCH_label_a1110;  /*opt-block+*/
28292                               
28293                               break;
28294                             case 3: 
28295                               { 
28296                                 unsigned idx = 
28297                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
28298                                 nextPC = 2 + MATCH_p; 
28299                                 
28300                                 #line 1753 "machine/pentium/disassembler.m"
28301                                 
28302 
28303                                         sprintf (str,  "FSUBRP.STi.ST", DIS_IDX);
28304 
28305                                 
28306 
28307                                 
28308                                 
28309                                 
28310                               }
28311                               
28312                               break;
28313                             default: assert(0);
28314                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28315                         break;
28316                       case 6: 
28317                         
28318                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28319                             case 0: 
28320                               
28321                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28322                                   case 0: case 1: case 2: case 3: case 6: 
28323                                   case 7: 
28324                                     { 
28325                                       unsigned Mem16 = 
28326                                         1 + addressToPC(MATCH_p);
28327                                       nextPC = 2 + MATCH_p; 
28328                                       
28329                                       #line 1526 "machine/pentium/disassembler.m"
28330                                       
28331 
28332                                               sprintf (str,  "FIDIV.I16", DIS_MEM16);
28333 
28334                                       
28335 
28336                                       
28337                                       
28338                                       
28339                                     }
28340                                     
28341                                     break;
28342                                   case 4: 
28343                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28344                                     if ((MATCH_w_8_16 & 0x7) 
28345                                             /* base at 16 */ == 5 && 
28346                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28347                                             /* index at 16 */ && 
28348                                       (MATCH_w_8_16 >> 3 & 0x7) 
28349                                             /* index at 16 */ < 8)) 
28350                                       goto MATCH_label_a1112;  /*opt-block+*/
28351                                     else 
28352                                       goto MATCH_label_a1111;  /*opt-block+*/
28353                                     
28354                                     break;
28355                                   case 5: 
28356                                     goto MATCH_label_a1113; break;
28357                                   default: assert(0);
28358                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28359                               break;
28360                             case 1: 
28361                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28362                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28363                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28364                                       /* index at 16 */ && 
28365                                 (MATCH_w_8_16 >> 3 & 0x7) 
28366                                       /* index at 16 */ < 8)) { 
28367                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
28368                                 nextPC = 4 + MATCH_p; 
28369                                 
28370                                 #line 1526 "machine/pentium/disassembler.m"
28371                                 
28372 
28373                                         sprintf (str,  "FIDIV.I16", DIS_MEM16);
28374 
28375                                 
28376 
28377                                 
28378                                 
28379                                 
28380                               } /*opt-block*//*opt-block+*/
28381                               else 
28382                                 goto MATCH_label_a1111;  /*opt-block+*/
28383                               
28384                               break;
28385                             case 2: 
28386                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28387                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28388                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28389                                       /* index at 16 */ && 
28390                                 (MATCH_w_8_16 >> 3 & 0x7) 
28391                                       /* index at 16 */ < 8)) 
28392                                 goto MATCH_label_a1112;  /*opt-block+*/
28393                               else 
28394                                 goto MATCH_label_a1113;  /*opt-block+*/
28395                               
28396                               break;
28397                             case 3: 
28398                               { 
28399                                 unsigned idx = 
28400                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
28401                                 nextPC = 2 + MATCH_p; 
28402                                 
28403                                 #line 1520 "machine/pentium/disassembler.m"
28404                                 
28405 
28406                                         sprintf (str,  "FDIVP.STi.ST", DIS_IDX);
28407 
28408                                 
28409 
28410                                 
28411                                 
28412                                 
28413                               }
28414                               
28415                               break;
28416                             default: assert(0);
28417                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28418                         break;
28419                       case 7: 
28420                         
28421                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28422                             case 0: 
28423                               
28424                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28425                                   case 0: case 1: case 2: case 3: case 6: 
28426                                   case 7: 
28427                                     { 
28428                                       unsigned Mem16 = 
28429                                         1 + addressToPC(MATCH_p);
28430                                       nextPC = 2 + MATCH_p; 
28431                                       
28432                                       #line 1544 "machine/pentium/disassembler.m"
28433                                       
28434 
28435                                               sprintf (str,  "FIDIVR.I16", DIS_MEM16);
28436 
28437                                       
28438 
28439                                       
28440                                       
28441                                       
28442                                     }
28443                                     
28444                                     break;
28445                                   case 4: 
28446                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28447                                     if ((MATCH_w_8_16 & 0x7) 
28448                                             /* base at 16 */ == 5 && 
28449                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28450                                             /* index at 16 */ && 
28451                                       (MATCH_w_8_16 >> 3 & 0x7) 
28452                                             /* index at 16 */ < 8)) 
28453                                       goto MATCH_label_a1115;  /*opt-block+*/
28454                                     else 
28455                                       goto MATCH_label_a1114;  /*opt-block+*/
28456                                     
28457                                     break;
28458                                   case 5: 
28459                                     goto MATCH_label_a1116; break;
28460                                   default: assert(0);
28461                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28462                               break;
28463                             case 1: 
28464                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28465                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28466                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28467                                       /* index at 16 */ && 
28468                                 (MATCH_w_8_16 >> 3 & 0x7) 
28469                                       /* index at 16 */ < 8)) { 
28470                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
28471                                 nextPC = 4 + MATCH_p; 
28472                                 
28473                                 #line 1544 "machine/pentium/disassembler.m"
28474                                 
28475 
28476                                         sprintf (str,  "FIDIVR.I16", DIS_MEM16);
28477 
28478                                 
28479 
28480                                 
28481                                 
28482                                 
28483                               } /*opt-block*//*opt-block+*/
28484                               else 
28485                                 goto MATCH_label_a1114;  /*opt-block+*/
28486                               
28487                               break;
28488                             case 2: 
28489                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28490                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28491                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28492                                       /* index at 16 */ && 
28493                                 (MATCH_w_8_16 >> 3 & 0x7) 
28494                                       /* index at 16 */ < 8)) 
28495                                 goto MATCH_label_a1115;  /*opt-block+*/
28496                               else 
28497                                 goto MATCH_label_a1116;  /*opt-block+*/
28498                               
28499                               break;
28500                             case 3: 
28501                               { 
28502                                 unsigned idx = 
28503                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
28504                                 nextPC = 2 + MATCH_p; 
28505                                 
28506                                 #line 1547 "machine/pentium/disassembler.m"
28507                                 
28508 
28509                                         sprintf (str,  "FDIVRP.STi.ST", DIS_IDX);
28510 
28511                                 
28512 
28513                                 
28514                                 
28515                                 
28516                               }
28517                               
28518                               break;
28519                             default: assert(0);
28520                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28521                         break;
28522                       default: assert(0);
28523                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
28524                   
28525                   break;
28526                 case 7: 
28527                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
28528                   
28529                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
28530                       case 0: 
28531                         
28532                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28533                             case 0: 
28534                               
28535                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28536                                   case 0: case 1: case 2: case 3: case 6: 
28537                                   case 7: 
28538                                     { 
28539                                       unsigned Mem16 = 
28540                                         1 + addressToPC(MATCH_p);
28541                                       nextPC = 2 + MATCH_p; 
28542                                       
28543                                       #line 1553 "machine/pentium/disassembler.m"
28544                                       
28545 
28546                                               sprintf (str,  "FILD.lsI16", DIS_MEM16);
28547 
28548                                       
28549 
28550                                       
28551                                       
28552                                       
28553                                     }
28554                                     
28555                                     break;
28556                                   case 4: 
28557                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28558                                     if ((MATCH_w_8_16 & 0x7) 
28559                                             /* base at 16 */ == 5 && 
28560                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28561                                             /* index at 16 */ && 
28562                                       (MATCH_w_8_16 >> 3 & 0x7) 
28563                                             /* index at 16 */ < 8)) 
28564                                       goto MATCH_label_a1118;  /*opt-block+*/
28565                                     else 
28566                                       goto MATCH_label_a1117;  /*opt-block+*/
28567                                     
28568                                     break;
28569                                   case 5: 
28570                                     goto MATCH_label_a1119; break;
28571                                   default: assert(0);
28572                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28573                               break;
28574                             case 1: 
28575                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28576                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28577                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28578                                       /* index at 16 */ && 
28579                                 (MATCH_w_8_16 >> 3 & 0x7) 
28580                                       /* index at 16 */ < 8)) { 
28581                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
28582                                 nextPC = 4 + MATCH_p; 
28583                                 
28584                                 #line 1553 "machine/pentium/disassembler.m"
28585                                 
28586 
28587                                         sprintf (str,  "FILD.lsI16", DIS_MEM16);
28588 
28589                                 
28590 
28591                                 
28592                                 
28593                                 
28594                               } /*opt-block*//*opt-block+*/
28595                               else 
28596                                 goto MATCH_label_a1117;  /*opt-block+*/
28597                               
28598                               break;
28599                             case 2: 
28600                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28601                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28602                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28603                                       /* index at 16 */ && 
28604                                 (MATCH_w_8_16 >> 3 & 0x7) 
28605                                       /* index at 16 */ < 8)) 
28606                                 goto MATCH_label_a1118;  /*opt-block+*/
28607                               else 
28608                                 goto MATCH_label_a1119;  /*opt-block+*/
28609                               
28610                               break;
28611                             case 3: 
28612                               goto MATCH_label_a39; break;
28613                             default: assert(0);
28614                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28615                         break;
28616                       case 1: 
28617                         goto MATCH_label_a39; break;
28618                       case 2: 
28619                         
28620                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28621                             case 0: 
28622                               
28623                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28624                                   case 0: case 1: case 2: case 3: case 6: 
28625                                   case 7: 
28626                                     { 
28627                                       unsigned Mem16 = 
28628                                         1 + addressToPC(MATCH_p);
28629                                       nextPC = 2 + MATCH_p; 
28630                                       
28631                                       #line 1565 "machine/pentium/disassembler.m"
28632                                       
28633 
28634                                               sprintf (str,  "FIST.lsI16", DIS_MEM16);
28635 
28636                                       
28637 
28638                                       
28639                                       
28640                                       
28641                                     }
28642                                     
28643                                     break;
28644                                   case 4: 
28645                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28646                                     if ((MATCH_w_8_16 & 0x7) 
28647                                             /* base at 16 */ == 5 && 
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                                       goto MATCH_label_a1121;  /*opt-block+*/
28653                                     else 
28654                                       goto MATCH_label_a1120;  /*opt-block+*/
28655                                     
28656                                     break;
28657                                   case 5: 
28658                                     goto MATCH_label_a1122; break;
28659                                   default: assert(0);
28660                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28661                               break;
28662                             case 1: 
28663                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28664                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28665                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28666                                       /* index at 16 */ && 
28667                                 (MATCH_w_8_16 >> 3 & 0x7) 
28668                                       /* index at 16 */ < 8)) { 
28669                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
28670                                 nextPC = 4 + MATCH_p; 
28671                                 
28672                                 #line 1565 "machine/pentium/disassembler.m"
28673                                 
28674 
28675                                         sprintf (str,  "FIST.lsI16", DIS_MEM16);
28676 
28677                                 
28678 
28679                                 
28680                                 
28681                                 
28682                               } /*opt-block*//*opt-block+*/
28683                               else 
28684                                 goto MATCH_label_a1120;  /*opt-block+*/
28685                               
28686                               break;
28687                             case 2: 
28688                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28689                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28690                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28691                                       /* index at 16 */ && 
28692                                 (MATCH_w_8_16 >> 3 & 0x7) 
28693                                       /* index at 16 */ < 8)) 
28694                                 goto MATCH_label_a1121;  /*opt-block+*/
28695                               else 
28696                                 goto MATCH_label_a1122;  /*opt-block+*/
28697                               
28698                               break;
28699                             case 3: 
28700                               goto MATCH_label_a39; break;
28701                             default: assert(0);
28702                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28703                         break;
28704                       case 3: 
28705                         
28706                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28707                             case 0: 
28708                               
28709                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28710                                   case 0: case 1: case 2: case 3: case 6: 
28711                                   case 7: 
28712                                     { 
28713                                       unsigned Mem16 = 
28714                                         1 + addressToPC(MATCH_p);
28715                                       nextPC = 2 + MATCH_p; 
28716                                       
28717                                       #line 1571 "machine/pentium/disassembler.m"
28718                                       
28719 
28720                                               sprintf (str,  "FISTP.lsI16", DIS_MEM16);
28721 
28722                                       
28723 
28724                                       
28725                                       
28726                                       
28727                                     }
28728                                     
28729                                     break;
28730                                   case 4: 
28731                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28732                                     if ((MATCH_w_8_16 & 0x7) 
28733                                             /* base at 16 */ == 5 && 
28734                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28735                                             /* index at 16 */ && 
28736                                       (MATCH_w_8_16 >> 3 & 0x7) 
28737                                             /* index at 16 */ < 8)) 
28738                                       goto MATCH_label_a1124;  /*opt-block+*/
28739                                     else 
28740                                       goto MATCH_label_a1123;  /*opt-block+*/
28741                                     
28742                                     break;
28743                                   case 5: 
28744                                     goto MATCH_label_a1125; break;
28745                                   default: assert(0);
28746                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28747                               break;
28748                             case 1: 
28749                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28750                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28751                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28752                                       /* index at 16 */ && 
28753                                 (MATCH_w_8_16 >> 3 & 0x7) 
28754                                       /* index at 16 */ < 8)) { 
28755                                 unsigned Mem16 = 1 + addressToPC(MATCH_p);
28756                                 nextPC = 4 + MATCH_p; 
28757                                 
28758                                 #line 1571 "machine/pentium/disassembler.m"
28759                                 
28760 
28761                                         sprintf (str,  "FISTP.lsI16", DIS_MEM16);
28762 
28763                                 
28764 
28765                                 
28766                                 
28767                                 
28768                               } /*opt-block*//*opt-block+*/
28769                               else 
28770                                 goto MATCH_label_a1123;  /*opt-block+*/
28771                               
28772                               break;
28773                             case 2: 
28774                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28775                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28776                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28777                                       /* index at 16 */ && 
28778                                 (MATCH_w_8_16 >> 3 & 0x7) 
28779                                       /* index at 16 */ < 8)) 
28780                                 goto MATCH_label_a1124;  /*opt-block+*/
28781                               else 
28782                                 goto MATCH_label_a1125;  /*opt-block+*/
28783                               
28784                               break;
28785                             case 3: 
28786                               goto MATCH_label_a39; break;
28787                             default: assert(0);
28788                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28789                         break;
28790                       case 4: 
28791                         
28792                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28793                             case 0: 
28794                               
28795                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28796                                   case 0: case 1: case 2: case 3: case 6: 
28797                                   case 7: 
28798                                     { 
28799                                       unsigned Mem80 = 
28800                                         1 + addressToPC(MATCH_p);
28801                                       nextPC = 2 + MATCH_p; 
28802                                       
28803                                       #line 1451 "machine/pentium/disassembler.m"
28804                                       
28805 
28806                                               sprintf (str,  "FBLD", DIS_MEM80);
28807 
28808                                       
28809 
28810                                       
28811                                       
28812                                       
28813                                     }
28814                                     
28815                                     break;
28816                                   case 4: 
28817                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28818                                     if ((MATCH_w_8_16 & 0x7) 
28819                                             /* base at 16 */ == 5 && 
28820                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28821                                             /* index at 16 */ && 
28822                                       (MATCH_w_8_16 >> 3 & 0x7) 
28823                                             /* index at 16 */ < 8)) 
28824                                       goto MATCH_label_a1127;  /*opt-block+*/
28825                                     else 
28826                                       goto MATCH_label_a1126;  /*opt-block+*/
28827                                     
28828                                     break;
28829                                   case 5: 
28830                                     goto MATCH_label_a1128; break;
28831                                   default: assert(0);
28832                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28833                               break;
28834                             case 1: 
28835                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28836                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28837                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28838                                       /* index at 16 */ && 
28839                                 (MATCH_w_8_16 >> 3 & 0x7) 
28840                                       /* index at 16 */ < 8)) { 
28841                                 unsigned Mem80 = 1 + addressToPC(MATCH_p);
28842                                 nextPC = 4 + MATCH_p; 
28843                                 
28844                                 #line 1451 "machine/pentium/disassembler.m"
28845                                 
28846 
28847                                         sprintf (str,  "FBLD", DIS_MEM80);
28848 
28849                                 
28850 
28851                                 
28852                                 
28853                                 
28854                               } /*opt-block*//*opt-block+*/
28855                               else 
28856                                 goto MATCH_label_a1126;  /*opt-block+*/
28857                               
28858                               break;
28859                             case 2: 
28860                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28861                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28862                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28863                                       /* index at 16 */ && 
28864                                 (MATCH_w_8_16 >> 3 & 0x7) 
28865                                       /* index at 16 */ < 8)) 
28866                                 goto MATCH_label_a1127;  /*opt-block+*/
28867                               else 
28868                                 goto MATCH_label_a1128;  /*opt-block+*/
28869                               
28870                               break;
28871                             case 3: 
28872                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 0) { 
28873                                 nextPC = 2 + MATCH_p; 
28874                                 
28875                                 #line 1711 "machine/pentium/disassembler.m"
28876                                 
28877 
28878                                         sprintf (str,  "FSTSW.AX");
28879 
28880                                 
28881 
28882                                 
28883                                 
28884                                 
28885                               } /*opt-block*//*opt-block+*/
28886                               else 
28887                                 goto MATCH_label_a39;  /*opt-block+*/
28888                               
28889                               break;
28890                             default: assert(0);
28891                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28892                         break;
28893                       case 5: 
28894                         
28895                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
28896                             case 0: 
28897                               
28898                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
28899                                   case 0: case 1: case 2: case 3: case 6: 
28900                                   case 7: 
28901                                     { 
28902                                       unsigned Mem64 = 
28903                                         1 + addressToPC(MATCH_p);
28904                                       nextPC = 2 + MATCH_p; 
28905                                       
28906                                       #line 1559 "machine/pentium/disassembler.m"
28907                                       
28908 
28909                                               sprintf (str,  "FILD64", DIS_MEM64);
28910 
28911                                       
28912 
28913                                       
28914                                       
28915                                       
28916                                     }
28917                                     
28918                                     break;
28919                                   case 4: 
28920                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
28921                                     if ((MATCH_w_8_16 & 0x7) 
28922                                             /* base at 16 */ == 5 && 
28923                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28924                                             /* index at 16 */ && 
28925                                       (MATCH_w_8_16 >> 3 & 0x7) 
28926                                             /* index at 16 */ < 8)) 
28927                                       goto MATCH_label_a1130;  /*opt-block+*/
28928                                     else 
28929                                       goto MATCH_label_a1129;  /*opt-block+*/
28930                                     
28931                                     break;
28932                                   case 5: 
28933                                     goto MATCH_label_a1131; break;
28934                                   default: assert(0);
28935                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
28936                               break;
28937                             case 1: 
28938                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28939                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28940                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28941                                       /* index at 16 */ && 
28942                                 (MATCH_w_8_16 >> 3 & 0x7) 
28943                                       /* index at 16 */ < 8)) { 
28944                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
28945                                 nextPC = 4 + MATCH_p; 
28946                                 
28947                                 #line 1559 "machine/pentium/disassembler.m"
28948                                 
28949 
28950                                         sprintf (str,  "FILD64", DIS_MEM64);
28951 
28952                                 
28953 
28954                                 
28955                                 
28956                                 
28957                               } /*opt-block*//*opt-block+*/
28958                               else 
28959                                 goto MATCH_label_a1129;  /*opt-block+*/
28960                               
28961                               break;
28962                             case 2: 
28963                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
28964                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
28965                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
28966                                       /* index at 16 */ && 
28967                                 (MATCH_w_8_16 >> 3 & 0x7) 
28968                                       /* index at 16 */ < 8)) 
28969                                 goto MATCH_label_a1130;  /*opt-block+*/
28970                               else 
28971                                 goto MATCH_label_a1131;  /*opt-block+*/
28972                               
28973                               break;
28974                             case 3: 
28975                               MATCH_name = "FUCOMIP.ST.STi"; 
28976                               { 
28977                                 char *name = MATCH_name;
28978                                 unsigned idx = 
28979                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
28980                                 nextPC = 2 + MATCH_p; 
28981                                 
28982                                 #line 1771 "machine/pentium/disassembler.m"
28983                                 
28984 
28985                                         sprintf (str, name, DIS_IDX);
28986 
28987                                 
28988 
28989                                 
28990                                 
28991                                 
28992                               }
28993                               
28994                               break;
28995                             default: assert(0);
28996                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
28997                         break;
28998                       case 6: 
28999                         
29000                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29001                             case 0: 
29002                               
29003                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29004                                   case 0: case 1: case 2: case 3: case 6: 
29005                                   case 7: 
29006                                     { 
29007                                       unsigned Mem80 = 
29008                                         1 + addressToPC(MATCH_p);
29009                                       nextPC = 2 + MATCH_p; 
29010                                       
29011                                       #line 1454 "machine/pentium/disassembler.m"
29012                                       
29013 
29014                                               sprintf (str,  "FBSTP", DIS_MEM80);
29015 
29016                                       
29017 
29018                                       
29019                                       
29020                                       
29021                                     }
29022                                     
29023                                     break;
29024                                   case 4: 
29025                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29026                                     if ((MATCH_w_8_16 & 0x7) 
29027                                             /* base at 16 */ == 5 && 
29028                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29029                                             /* index at 16 */ && 
29030                                       (MATCH_w_8_16 >> 3 & 0x7) 
29031                                             /* index at 16 */ < 8)) 
29032                                       goto MATCH_label_a1133;  /*opt-block+*/
29033                                     else 
29034                                       goto MATCH_label_a1132;  /*opt-block+*/
29035                                     
29036                                     break;
29037                                   case 5: 
29038                                     goto MATCH_label_a1134; break;
29039                                   default: assert(0);
29040                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29041                               break;
29042                             case 1: 
29043                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29044                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29045                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29046                                       /* index at 16 */ && 
29047                                 (MATCH_w_8_16 >> 3 & 0x7) 
29048                                       /* index at 16 */ < 8)) { 
29049                                 unsigned Mem80 = 1 + addressToPC(MATCH_p);
29050                                 nextPC = 4 + MATCH_p; 
29051                                 
29052                                 #line 1454 "machine/pentium/disassembler.m"
29053                                 
29054 
29055                                         sprintf (str,  "FBSTP", DIS_MEM80);
29056 
29057                                 
29058 
29059                                 
29060                                 
29061                                 
29062                               } /*opt-block*//*opt-block+*/
29063                               else 
29064                                 goto MATCH_label_a1132;  /*opt-block+*/
29065                               
29066                               break;
29067                             case 2: 
29068                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29069                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29070                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29071                                       /* index at 16 */ && 
29072                                 (MATCH_w_8_16 >> 3 & 0x7) 
29073                                       /* index at 16 */ < 8)) 
29074                                 goto MATCH_label_a1133;  /*opt-block+*/
29075                               else 
29076                                 goto MATCH_label_a1134;  /*opt-block+*/
29077                               
29078                               break;
29079                             case 3: 
29080                               MATCH_name = "FCOMIP.ST.STi"; 
29081                               { 
29082                                 char *name = MATCH_name;
29083                                 unsigned idx = 
29084                                   (MATCH_w_8_8 & 0x7) /* r_m at 8 */;
29085                                 nextPC = 2 + MATCH_p; 
29086                                 
29087                                 #line 1499 "machine/pentium/disassembler.m"
29088                                 
29089 
29090                                         sprintf (str, name, DIS_IDX);
29091 
29092                                 
29093 
29094                                 
29095                                 
29096                                 
29097                               }
29098                               
29099                               break;
29100                             default: assert(0);
29101                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29102                         break;
29103                       case 7: 
29104                         
29105                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29106                             case 0: 
29107                               
29108                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29109                                   case 0: case 1: case 2: case 3: case 6: 
29110                                   case 7: 
29111                                     { 
29112                                       unsigned Mem64 = 
29113                                         1 + addressToPC(MATCH_p);
29114                                       nextPC = 2 + MATCH_p; 
29115                                       
29116                                       #line 1577 "machine/pentium/disassembler.m"
29117                                       
29118 
29119                                               sprintf (str,  "FISTP64", DIS_MEM64);
29120 
29121                                       
29122 
29123                                       
29124                                       
29125                                       
29126                                     }
29127                                     
29128                                     break;
29129                                   case 4: 
29130                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29131                                     if ((MATCH_w_8_16 & 0x7) 
29132                                             /* base at 16 */ == 5 && 
29133                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29134                                             /* index at 16 */ && 
29135                                       (MATCH_w_8_16 >> 3 & 0x7) 
29136                                             /* index at 16 */ < 8)) 
29137                                       goto MATCH_label_a1136;  /*opt-block+*/
29138                                     else 
29139                                       goto MATCH_label_a1135;  /*opt-block+*/
29140                                     
29141                                     break;
29142                                   case 5: 
29143                                     goto MATCH_label_a1137; break;
29144                                   default: assert(0);
29145                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29146                               break;
29147                             case 1: 
29148                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29149                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29150                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29151                                       /* index at 16 */ && 
29152                                 (MATCH_w_8_16 >> 3 & 0x7) 
29153                                       /* index at 16 */ < 8)) { 
29154                                 unsigned Mem64 = 1 + addressToPC(MATCH_p);
29155                                 nextPC = 4 + MATCH_p; 
29156                                 
29157                                 #line 1577 "machine/pentium/disassembler.m"
29158                                 
29159 
29160                                         sprintf (str,  "FISTP64", DIS_MEM64);
29161 
29162                                 
29163 
29164                                 
29165                                 
29166                                 
29167                               } /*opt-block*//*opt-block+*/
29168                               else 
29169                                 goto MATCH_label_a1135;  /*opt-block+*/
29170                               
29171                               break;
29172                             case 2: 
29173                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29174                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29175                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29176                                       /* index at 16 */ && 
29177                                 (MATCH_w_8_16 >> 3 & 0x7) 
29178                                       /* index at 16 */ < 8)) 
29179                                 goto MATCH_label_a1136;  /*opt-block+*/
29180                               else 
29181                                 goto MATCH_label_a1137;  /*opt-block+*/
29182                               
29183                               break;
29184                             case 3: 
29185                               goto MATCH_label_a39; break;
29186                             default: assert(0);
29187                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29188                         break;
29189                       default: assert(0);
29190                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
29191                   
29192                   break;
29193                 default: assert(0);
29194               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/  
29195           else 
29196             
29197               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
29198                 case 0: 
29199                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
29200                   
29201                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
29202                       case 0: 
29203                         
29204                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29205                             case 0: 
29206                               
29207                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29208                                   case 0: case 1: case 2: case 3: case 6: 
29209                                   case 7: 
29210                                     goto MATCH_label_a855; break;
29211                                   case 4: 
29212                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29213                                     if ((MATCH_w_8_16 & 0x7) 
29214                                             /* base at 16 */ == 5 && 
29215                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29216                                             /* index at 16 */ && 
29217                                       (MATCH_w_8_16 >> 3 & 0x7) 
29218                                             /* index at 16 */ < 8)) 
29219                                       goto MATCH_label_a857;  /*opt-block+*/
29220                                     else 
29221                                       goto MATCH_label_a856;  /*opt-block+*/
29222                                     
29223                                     break;
29224                                   case 5: 
29225                                     goto MATCH_label_a858; break;
29226                                   default: assert(0);
29227                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29228                               break;
29229                             case 1: 
29230                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29231                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29232                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29233                                       /* index at 16 */ && 
29234                                 (MATCH_w_8_16 >> 3 & 0x7) 
29235                                       /* index at 16 */ < 8)) { 
29236                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
29237                                 nextPC = 4 + MATCH_p; 
29238                                 
29239                                 #line 492 "machine/pentium/disassembler.m"
29240                                 
29241 
29242                                         sprintf (str,  "ROLB.Eb.1", DIS_EADDR8);
29243 
29244                                 
29245 
29246                                 
29247                                 
29248                                 
29249                               } /*opt-block*//*opt-block+*/
29250                               else 
29251                                 goto MATCH_label_a856;  /*opt-block+*/
29252                               
29253                               break;
29254                             case 2: 
29255                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29256                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29257                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29258                                       /* index at 16 */ && 
29259                                 (MATCH_w_8_16 >> 3 & 0x7) 
29260                                       /* index at 16 */ < 8)) 
29261                                 goto MATCH_label_a857;  /*opt-block+*/
29262                               else 
29263                                 goto MATCH_label_a858;  /*opt-block+*/
29264                               
29265                               break;
29266                             case 3: 
29267                               goto MATCH_label_a855; break;
29268                             default: assert(0);
29269                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29270                         break;
29271                       case 1: 
29272                         
29273                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29274                             case 0: 
29275                               
29276                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29277                                   case 0: case 1: case 2: case 3: case 6: 
29278                                   case 7: 
29279                                     goto MATCH_label_a859; break;
29280                                   case 4: 
29281                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29282                                     if ((MATCH_w_8_16 & 0x7) 
29283                                             /* base at 16 */ == 5 && 
29284                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29285                                             /* index at 16 */ && 
29286                                       (MATCH_w_8_16 >> 3 & 0x7) 
29287                                             /* index at 16 */ < 8)) 
29288                                       goto MATCH_label_a861;  /*opt-block+*/
29289                                     else 
29290                                       goto MATCH_label_a860;  /*opt-block+*/
29291                                     
29292                                     break;
29293                                   case 5: 
29294                                     goto MATCH_label_a862; break;
29295                                   default: assert(0);
29296                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29297                               break;
29298                             case 1: 
29299                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29300                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29301                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29302                                       /* index at 16 */ && 
29303                                 (MATCH_w_8_16 >> 3 & 0x7) 
29304                                       /* index at 16 */ < 8)) { 
29305                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
29306                                 nextPC = 4 + MATCH_p; 
29307                                 
29308                                 #line 486 "machine/pentium/disassembler.m"
29309                                 
29310 
29311                                         sprintf (str,  "RORB.Eb.1", DIS_EADDR8);
29312 
29313                                 
29314 
29315                                 
29316                                 
29317                                 
29318                               } /*opt-block*//*opt-block+*/
29319                               else 
29320                                 goto MATCH_label_a860;  /*opt-block+*/
29321                               
29322                               break;
29323                             case 2: 
29324                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29325                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29326                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29327                                       /* index at 16 */ && 
29328                                 (MATCH_w_8_16 >> 3 & 0x7) 
29329                                       /* index at 16 */ < 8)) 
29330                                 goto MATCH_label_a861;  /*opt-block+*/
29331                               else 
29332                                 goto MATCH_label_a862;  /*opt-block+*/
29333                               
29334                               break;
29335                             case 3: 
29336                               goto MATCH_label_a859; break;
29337                             default: assert(0);
29338                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29339                         break;
29340                       case 2: 
29341                         
29342                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29343                             case 0: 
29344                               
29345                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29346                                   case 0: case 1: case 2: case 3: case 6: 
29347                                   case 7: 
29348                                     goto MATCH_label_a863; break;
29349                                   case 4: 
29350                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29351                                     if ((MATCH_w_8_16 & 0x7) 
29352                                             /* base at 16 */ == 5 && 
29353                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29354                                             /* index at 16 */ && 
29355                                       (MATCH_w_8_16 >> 3 & 0x7) 
29356                                             /* index at 16 */ < 8)) 
29357                                       goto MATCH_label_a865;  /*opt-block+*/
29358                                     else 
29359                                       goto MATCH_label_a864;  /*opt-block+*/
29360                                     
29361                                     break;
29362                                   case 5: 
29363                                     goto MATCH_label_a866; break;
29364                                   default: assert(0);
29365                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29366                               break;
29367                             case 1: 
29368                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29369                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29370                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29371                                       /* index at 16 */ && 
29372                                 (MATCH_w_8_16 >> 3 & 0x7) 
29373                                       /* index at 16 */ < 8)) { 
29374                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
29375                                 nextPC = 4 + MATCH_p; 
29376                                 
29377                                 #line 480 "machine/pentium/disassembler.m"
29378                                 
29379 
29380                                         sprintf (str,  "RCLB.Eb.1", DIS_EADDR8);
29381 
29382                                 
29383 
29384                                 
29385                                 
29386                                 
29387                               } /*opt-block*//*opt-block+*/
29388                               else 
29389                                 goto MATCH_label_a864;  /*opt-block+*/
29390                               
29391                               break;
29392                             case 2: 
29393                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29394                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29395                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29396                                       /* index at 16 */ && 
29397                                 (MATCH_w_8_16 >> 3 & 0x7) 
29398                                       /* index at 16 */ < 8)) 
29399                                 goto MATCH_label_a865;  /*opt-block+*/
29400                               else 
29401                                 goto MATCH_label_a866;  /*opt-block+*/
29402                               
29403                               break;
29404                             case 3: 
29405                               goto MATCH_label_a863; break;
29406                             default: assert(0);
29407                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29408                         break;
29409                       case 3: 
29410                         
29411                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29412                             case 0: 
29413                               
29414                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29415                                   case 0: case 1: case 2: case 3: case 6: 
29416                                   case 7: 
29417                                     goto MATCH_label_a867; break;
29418                                   case 4: 
29419                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29420                                     if ((MATCH_w_8_16 & 0x7) 
29421                                             /* base at 16 */ == 5 && 
29422                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29423                                             /* index at 16 */ && 
29424                                       (MATCH_w_8_16 >> 3 & 0x7) 
29425                                             /* index at 16 */ < 8)) 
29426                                       goto MATCH_label_a869;  /*opt-block+*/
29427                                     else 
29428                                       goto MATCH_label_a868;  /*opt-block+*/
29429                                     
29430                                     break;
29431                                   case 5: 
29432                                     goto MATCH_label_a870; break;
29433                                   default: assert(0);
29434                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29435                               break;
29436                             case 1: 
29437                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29438                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29439                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29440                                       /* index at 16 */ && 
29441                                 (MATCH_w_8_16 >> 3 & 0x7) 
29442                                       /* index at 16 */ < 8)) { 
29443                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
29444                                 nextPC = 4 + MATCH_p; 
29445                                 
29446                                 #line 474 "machine/pentium/disassembler.m"
29447                                 
29448 
29449                                         sprintf (str,  "RCRB.Eb.1", DIS_EADDR8);
29450 
29451                                 
29452 
29453                                 
29454                                 
29455                                 
29456                               } /*opt-block*//*opt-block+*/
29457                               else 
29458                                 goto MATCH_label_a868;  /*opt-block+*/
29459                               
29460                               break;
29461                             case 2: 
29462                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29463                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29464                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29465                                       /* index at 16 */ && 
29466                                 (MATCH_w_8_16 >> 3 & 0x7) 
29467                                       /* index at 16 */ < 8)) 
29468                                 goto MATCH_label_a869;  /*opt-block+*/
29469                               else 
29470                                 goto MATCH_label_a870;  /*opt-block+*/
29471                               
29472                               break;
29473                             case 3: 
29474                               goto MATCH_label_a867; break;
29475                             default: assert(0);
29476                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29477                         break;
29478                       case 4: 
29479                         
29480                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29481                             case 0: 
29482                               
29483                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29484                                   case 0: case 1: case 2: case 3: case 6: 
29485                                   case 7: 
29486                                     goto MATCH_label_a871; break;
29487                                   case 4: 
29488                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29489                                     if ((MATCH_w_8_16 & 0x7) 
29490                                             /* base at 16 */ == 5 && 
29491                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29492                                             /* index at 16 */ && 
29493                                       (MATCH_w_8_16 >> 3 & 0x7) 
29494                                             /* index at 16 */ < 8)) 
29495                                       goto MATCH_label_a873;  /*opt-block+*/
29496                                     else 
29497                                       goto MATCH_label_a872;  /*opt-block+*/
29498                                     
29499                                     break;
29500                                   case 5: 
29501                                     goto MATCH_label_a874; break;
29502                                   default: assert(0);
29503                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29504                               break;
29505                             case 1: 
29506                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29507                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29508                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29509                                       /* index at 16 */ && 
29510                                 (MATCH_w_8_16 >> 3 & 0x7) 
29511                                       /* index at 16 */ < 8)) { 
29512                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
29513                                 nextPC = 4 + MATCH_p; 
29514                                 
29515                                 #line 468 "machine/pentium/disassembler.m"
29516                                 
29517 
29518                                         sprintf (str,  "SHLSALB.Eb.1", DIS_EADDR8);
29519 
29520                                 
29521 
29522                                 
29523                                 
29524                                 
29525                               } /*opt-block*//*opt-block+*/
29526                               else 
29527                                 goto MATCH_label_a872;  /*opt-block+*/
29528                               
29529                               break;
29530                             case 2: 
29531                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29532                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29533                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29534                                       /* index at 16 */ && 
29535                                 (MATCH_w_8_16 >> 3 & 0x7) 
29536                                       /* index at 16 */ < 8)) 
29537                                 goto MATCH_label_a873;  /*opt-block+*/
29538                               else 
29539                                 goto MATCH_label_a874;  /*opt-block+*/
29540                               
29541                               break;
29542                             case 3: 
29543                               goto MATCH_label_a871; break;
29544                             default: assert(0);
29545                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29546                         break;
29547                       case 5: 
29548                         
29549                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29550                             case 0: 
29551                               
29552                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29553                                   case 0: case 1: case 2: case 3: case 6: 
29554                                   case 7: 
29555                                     goto MATCH_label_a875; break;
29556                                   case 4: 
29557                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29558                                     if ((MATCH_w_8_16 & 0x7) 
29559                                             /* base at 16 */ == 5 && 
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                                       goto MATCH_label_a877;  /*opt-block+*/
29565                                     else 
29566                                       goto MATCH_label_a876;  /*opt-block+*/
29567                                     
29568                                     break;
29569                                   case 5: 
29570                                     goto MATCH_label_a878; break;
29571                                   default: assert(0);
29572                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29573                               break;
29574                             case 1: 
29575                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29576                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29577                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29578                                       /* index at 16 */ && 
29579                                 (MATCH_w_8_16 >> 3 & 0x7) 
29580                                       /* index at 16 */ < 8)) { 
29581                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
29582                                 nextPC = 4 + MATCH_p; 
29583                                 
29584                                 #line 462 "machine/pentium/disassembler.m"
29585                                 
29586 
29587                                         sprintf (str,  "SHRB.Eb.1", DIS_EADDR8);
29588 
29589                                 
29590 
29591                                 
29592                                 
29593                                 
29594                               } /*opt-block*//*opt-block+*/
29595                               else 
29596                                 goto MATCH_label_a876;  /*opt-block+*/
29597                               
29598                               break;
29599                             case 2: 
29600                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29601                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29602                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29603                                       /* index at 16 */ && 
29604                                 (MATCH_w_8_16 >> 3 & 0x7) 
29605                                       /* index at 16 */ < 8)) 
29606                                 goto MATCH_label_a877;  /*opt-block+*/
29607                               else 
29608                                 goto MATCH_label_a878;  /*opt-block+*/
29609                               
29610                               break;
29611                             case 3: 
29612                               goto MATCH_label_a875; break;
29613                             default: assert(0);
29614                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29615                         break;
29616                       case 6: 
29617                         goto MATCH_label_a39; break;
29618                       case 7: 
29619                         
29620                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29621                             case 0: 
29622                               
29623                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29624                                   case 0: case 1: case 2: case 3: case 6: 
29625                                   case 7: 
29626                                     goto MATCH_label_a879; break;
29627                                   case 4: 
29628                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29629                                     if ((MATCH_w_8_16 & 0x7) 
29630                                             /* base at 16 */ == 5 && 
29631                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29632                                             /* index at 16 */ && 
29633                                       (MATCH_w_8_16 >> 3 & 0x7) 
29634                                             /* index at 16 */ < 8)) 
29635                                       goto MATCH_label_a881;  /*opt-block+*/
29636                                     else 
29637                                       goto MATCH_label_a880;  /*opt-block+*/
29638                                     
29639                                     break;
29640                                   case 5: 
29641                                     goto MATCH_label_a882; break;
29642                                   default: assert(0);
29643                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29644                               break;
29645                             case 1: 
29646                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29647                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29648                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29649                                       /* index at 16 */ && 
29650                                 (MATCH_w_8_16 >> 3 & 0x7) 
29651                                       /* index at 16 */ < 8)) { 
29652                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
29653                                 nextPC = 4 + MATCH_p; 
29654                                 
29655                                 #line 456 "machine/pentium/disassembler.m"
29656                                 
29657 
29658                                         sprintf (str,  "SARB.Eb.1", DIS_EADDR16);
29659 
29660                                 
29661 
29662                                 
29663                                 
29664                                 
29665                               } /*opt-block*//*opt-block+*/
29666                               else 
29667                                 goto MATCH_label_a880;  /*opt-block+*/
29668                               
29669                               break;
29670                             case 2: 
29671                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29672                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29673                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29674                                       /* index at 16 */ && 
29675                                 (MATCH_w_8_16 >> 3 & 0x7) 
29676                                       /* index at 16 */ < 8)) 
29677                                 goto MATCH_label_a881;  /*opt-block+*/
29678                               else 
29679                                 goto MATCH_label_a882;  /*opt-block+*/
29680                               
29681                               break;
29682                             case 3: 
29683                               goto MATCH_label_a879; break;
29684                             default: assert(0);
29685                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29686                         break;
29687                       default: assert(0);
29688                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
29689                   
29690                   break;
29691                 case 1: 
29692                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
29693                   
29694                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
29695                       case 0: 
29696                         
29697                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29698                             case 0: 
29699                               
29700                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29701                                   case 0: case 1: case 2: case 3: case 6: 
29702                                   case 7: 
29703                                     goto MATCH_label_a883; break;
29704                                   case 4: 
29705                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29706                                     if ((MATCH_w_8_16 & 0x7) 
29707                                             /* base at 16 */ == 5 && 
29708                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29709                                             /* index at 16 */ && 
29710                                       (MATCH_w_8_16 >> 3 & 0x7) 
29711                                             /* index at 16 */ < 8)) 
29712                                       goto MATCH_label_a885;  /*opt-block+*/
29713                                     else 
29714                                       goto MATCH_label_a884;  /*opt-block+*/
29715                                     
29716                                     break;
29717                                   case 5: 
29718                                     goto MATCH_label_a886; 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                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
29730                                 nextPC = 4 + MATCH_p; 
29731                                 
29732                                 #line 447 "machine/pentium/disassembler.m"
29733                                 
29734 
29735                                         sprintf (str,  "ROLB.Ev.1od", DIS_EADDR32);
29736 
29737                                 
29738 
29739                                 
29740                                 
29741                                 
29742                               } /*opt-block*//*opt-block+*/
29743                               else 
29744                                 goto MATCH_label_a884;  /*opt-block+*/
29745                               
29746                               break;
29747                             case 2: 
29748                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29749                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29750                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29751                                       /* index at 16 */ && 
29752                                 (MATCH_w_8_16 >> 3 & 0x7) 
29753                                       /* index at 16 */ < 8)) 
29754                                 goto MATCH_label_a885;  /*opt-block+*/
29755                               else 
29756                                 goto MATCH_label_a886;  /*opt-block+*/
29757                               
29758                               break;
29759                             case 3: 
29760                               goto MATCH_label_a883; break;
29761                             default: assert(0);
29762                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29763                         break;
29764                       case 1: 
29765                         
29766                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29767                             case 0: 
29768                               
29769                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29770                                   case 0: case 1: case 2: case 3: case 6: 
29771                                   case 7: 
29772                                     goto MATCH_label_a887; break;
29773                                   case 4: 
29774                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29775                                     if ((MATCH_w_8_16 & 0x7) 
29776                                             /* base at 16 */ == 5 && 
29777                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29778                                             /* index at 16 */ && 
29779                                       (MATCH_w_8_16 >> 3 & 0x7) 
29780                                             /* index at 16 */ < 8)) 
29781                                       goto MATCH_label_a889;  /*opt-block+*/
29782                                     else 
29783                                       goto MATCH_label_a888;  /*opt-block+*/
29784                                     
29785                                     break;
29786                                   case 5: 
29787                                     goto MATCH_label_a890; break;
29788                                   default: assert(0);
29789                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29790                               break;
29791                             case 1: 
29792                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29793                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29794                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29795                                       /* index at 16 */ && 
29796                                 (MATCH_w_8_16 >> 3 & 0x7) 
29797                                       /* index at 16 */ < 8)) { 
29798                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
29799                                 nextPC = 4 + MATCH_p; 
29800                                 
29801                                 #line 435 "machine/pentium/disassembler.m"
29802                                 
29803 
29804                                         sprintf (str,  "RORB.Ev.1od", DIS_EADDR32);
29805 
29806                                 
29807 
29808                                 
29809                                 
29810                                 
29811                               } /*opt-block*//*opt-block+*/
29812                               else 
29813                                 goto MATCH_label_a888;  /*opt-block+*/
29814                               
29815                               break;
29816                             case 2: 
29817                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29818                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29819                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29820                                       /* index at 16 */ && 
29821                                 (MATCH_w_8_16 >> 3 & 0x7) 
29822                                       /* index at 16 */ < 8)) 
29823                                 goto MATCH_label_a889;  /*opt-block+*/
29824                               else 
29825                                 goto MATCH_label_a890;  /*opt-block+*/
29826                               
29827                               break;
29828                             case 3: 
29829                               goto MATCH_label_a887; break;
29830                             default: assert(0);
29831                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29832                         break;
29833                       case 2: 
29834                         
29835                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29836                             case 0: 
29837                               
29838                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29839                                   case 0: case 1: case 2: case 3: case 6: 
29840                                   case 7: 
29841                                     goto MATCH_label_a891; break;
29842                                   case 4: 
29843                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29844                                     if ((MATCH_w_8_16 & 0x7) 
29845                                             /* base at 16 */ == 5 && 
29846                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29847                                             /* index at 16 */ && 
29848                                       (MATCH_w_8_16 >> 3 & 0x7) 
29849                                             /* index at 16 */ < 8)) 
29850                                       goto MATCH_label_a893;  /*opt-block+*/
29851                                     else 
29852                                       goto MATCH_label_a892;  /*opt-block+*/
29853                                     
29854                                     break;
29855                                   case 5: 
29856                                     goto MATCH_label_a894; break;
29857                                   default: assert(0);
29858                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29859                               break;
29860                             case 1: 
29861                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29862                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29863                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29864                                       /* index at 16 */ && 
29865                                 (MATCH_w_8_16 >> 3 & 0x7) 
29866                                       /* index at 16 */ < 8)) { 
29867                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
29868                                 nextPC = 4 + MATCH_p; 
29869                                 
29870                                 #line 423 "machine/pentium/disassembler.m"
29871                                 
29872 
29873                                         sprintf (str,  "RCLB.Ev.1od", DIS_EADDR32);
29874 
29875                                 
29876 
29877                                 
29878                                 
29879                                 
29880                               } /*opt-block*//*opt-block+*/
29881                               else 
29882                                 goto MATCH_label_a892;  /*opt-block+*/
29883                               
29884                               break;
29885                             case 2: 
29886                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29887                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29888                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29889                                       /* index at 16 */ && 
29890                                 (MATCH_w_8_16 >> 3 & 0x7) 
29891                                       /* index at 16 */ < 8)) 
29892                                 goto MATCH_label_a893;  /*opt-block+*/
29893                               else 
29894                                 goto MATCH_label_a894;  /*opt-block+*/
29895                               
29896                               break;
29897                             case 3: 
29898                               goto MATCH_label_a891; break;
29899                             default: assert(0);
29900                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29901                         break;
29902                       case 3: 
29903                         
29904                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29905                             case 0: 
29906                               
29907                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29908                                   case 0: case 1: case 2: case 3: case 6: 
29909                                   case 7: 
29910                                     goto MATCH_label_a895; break;
29911                                   case 4: 
29912                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29913                                     if ((MATCH_w_8_16 & 0x7) 
29914                                             /* base at 16 */ == 5 && 
29915                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29916                                             /* index at 16 */ && 
29917                                       (MATCH_w_8_16 >> 3 & 0x7) 
29918                                             /* index at 16 */ < 8)) 
29919                                       goto MATCH_label_a897;  /*opt-block+*/
29920                                     else 
29921                                       goto MATCH_label_a896;  /*opt-block+*/
29922                                     
29923                                     break;
29924                                   case 5: 
29925                                     goto MATCH_label_a898; break;
29926                                   default: assert(0);
29927                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29928                               break;
29929                             case 1: 
29930                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29931                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29932                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29933                                       /* index at 16 */ && 
29934                                 (MATCH_w_8_16 >> 3 & 0x7) 
29935                                       /* index at 16 */ < 8)) { 
29936                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
29937                                 nextPC = 4 + MATCH_p; 
29938                                 
29939                                 #line 411 "machine/pentium/disassembler.m"
29940                                 
29941 
29942                                         sprintf (str,  "RCRB.Ev.1od", DIS_EADDR32);
29943 
29944                                 
29945 
29946                                 
29947                                 
29948                                 
29949                               } /*opt-block*//*opt-block+*/
29950                               else 
29951                                 goto MATCH_label_a896;  /*opt-block+*/
29952                               
29953                               break;
29954                             case 2: 
29955                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
29956                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
29957                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29958                                       /* index at 16 */ && 
29959                                 (MATCH_w_8_16 >> 3 & 0x7) 
29960                                       /* index at 16 */ < 8)) 
29961                                 goto MATCH_label_a897;  /*opt-block+*/
29962                               else 
29963                                 goto MATCH_label_a898;  /*opt-block+*/
29964                               
29965                               break;
29966                             case 3: 
29967                               goto MATCH_label_a895; break;
29968                             default: assert(0);
29969                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
29970                         break;
29971                       case 4: 
29972                         
29973                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
29974                             case 0: 
29975                               
29976                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
29977                                   case 0: case 1: case 2: case 3: case 6: 
29978                                   case 7: 
29979                                     goto MATCH_label_a899; break;
29980                                   case 4: 
29981                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
29982                                     if ((MATCH_w_8_16 & 0x7) 
29983                                             /* base at 16 */ == 5 && 
29984                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
29985                                             /* index at 16 */ && 
29986                                       (MATCH_w_8_16 >> 3 & 0x7) 
29987                                             /* index at 16 */ < 8)) 
29988                                       goto MATCH_label_a901;  /*opt-block+*/
29989                                     else 
29990                                       goto MATCH_label_a900;  /*opt-block+*/
29991                                     
29992                                     break;
29993                                   case 5: 
29994                                     goto MATCH_label_a902; break;
29995                                   default: assert(0);
29996                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
29997                               break;
29998                             case 1: 
29999                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30000                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30001                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30002                                       /* index at 16 */ && 
30003                                 (MATCH_w_8_16 >> 3 & 0x7) 
30004                                       /* index at 16 */ < 8)) { 
30005                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
30006                                 nextPC = 4 + MATCH_p; 
30007                                 
30008                                 #line 399 "machine/pentium/disassembler.m"
30009                                 
30010 
30011                                         sprintf (str,  "SHLSALB.Ev.1od", DIS_EADDR32);
30012 
30013                                 
30014 
30015                                 
30016                                 
30017                                 
30018                               } /*opt-block*//*opt-block+*/
30019                               else 
30020                                 goto MATCH_label_a900;  /*opt-block+*/
30021                               
30022                               break;
30023                             case 2: 
30024                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30025                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30026                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30027                                       /* index at 16 */ && 
30028                                 (MATCH_w_8_16 >> 3 & 0x7) 
30029                                       /* index at 16 */ < 8)) 
30030                                 goto MATCH_label_a901;  /*opt-block+*/
30031                               else 
30032                                 goto MATCH_label_a902;  /*opt-block+*/
30033                               
30034                               break;
30035                             case 3: 
30036                               goto MATCH_label_a899; break;
30037                             default: assert(0);
30038                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30039                         break;
30040                       case 5: 
30041                         
30042                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30043                             case 0: 
30044                               
30045                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30046                                   case 0: case 1: case 2: case 3: case 6: 
30047                                   case 7: 
30048                                     goto MATCH_label_a903; break;
30049                                   case 4: 
30050                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30051                                     if ((MATCH_w_8_16 & 0x7) 
30052                                             /* base at 16 */ == 5 && 
30053                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30054                                             /* index at 16 */ && 
30055                                       (MATCH_w_8_16 >> 3 & 0x7) 
30056                                             /* index at 16 */ < 8)) 
30057                                       goto MATCH_label_a905;  /*opt-block+*/
30058                                     else 
30059                                       goto MATCH_label_a904;  /*opt-block+*/
30060                                     
30061                                     break;
30062                                   case 5: 
30063                                     goto MATCH_label_a906; break;
30064                                   default: assert(0);
30065                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30066                               break;
30067                             case 1: 
30068                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30069                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30070                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30071                                       /* index at 16 */ && 
30072                                 (MATCH_w_8_16 >> 3 & 0x7) 
30073                                       /* index at 16 */ < 8)) { 
30074                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
30075                                 nextPC = 4 + MATCH_p; 
30076                                 
30077                                 #line 387 "machine/pentium/disassembler.m"
30078                                 
30079 
30080                                         sprintf (str,  "SHRB.Ev.1od", DIS_EADDR32);
30081 
30082                                 
30083 
30084                                 
30085                                 
30086                                 
30087                               } /*opt-block*//*opt-block+*/
30088                               else 
30089                                 goto MATCH_label_a904;  /*opt-block+*/
30090                               
30091                               break;
30092                             case 2: 
30093                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30094                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30095                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30096                                       /* index at 16 */ && 
30097                                 (MATCH_w_8_16 >> 3 & 0x7) 
30098                                       /* index at 16 */ < 8)) 
30099                                 goto MATCH_label_a905;  /*opt-block+*/
30100                               else 
30101                                 goto MATCH_label_a906;  /*opt-block+*/
30102                               
30103                               break;
30104                             case 3: 
30105                               goto MATCH_label_a903; break;
30106                             default: assert(0);
30107                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30108                         break;
30109                       case 6: 
30110                         goto MATCH_label_a39; break;
30111                       case 7: 
30112                         
30113                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30114                             case 0: 
30115                               
30116                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30117                                   case 0: case 1: case 2: case 3: case 6: 
30118                                   case 7: 
30119                                     goto MATCH_label_a907; break;
30120                                   case 4: 
30121                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30122                                     if ((MATCH_w_8_16 & 0x7) 
30123                                             /* base at 16 */ == 5 && 
30124                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30125                                             /* index at 16 */ && 
30126                                       (MATCH_w_8_16 >> 3 & 0x7) 
30127                                             /* index at 16 */ < 8)) 
30128                                       goto MATCH_label_a909;  /*opt-block+*/
30129                                     else 
30130                                       goto MATCH_label_a908;  /*opt-block+*/
30131                                     
30132                                     break;
30133                                   case 5: 
30134                                     goto MATCH_label_a910; break;
30135                                   default: assert(0);
30136                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30137                               break;
30138                             case 1: 
30139                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30140                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30141                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30142                                       /* index at 16 */ && 
30143                                 (MATCH_w_8_16 >> 3 & 0x7) 
30144                                       /* index at 16 */ < 8)) { 
30145                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
30146                                 nextPC = 4 + MATCH_p; 
30147                                 
30148                                 #line 375 "machine/pentium/disassembler.m"
30149                                 
30150 
30151                                         sprintf (str,  "SARB.Ev.1od", DIS_EADDR32);
30152 
30153                                 
30154 
30155                                 
30156                                 
30157                                 
30158                               } /*opt-block*//*opt-block+*/
30159                               else 
30160                                 goto MATCH_label_a908;  /*opt-block+*/
30161                               
30162                               break;
30163                             case 2: 
30164                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30165                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30166                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30167                                       /* index at 16 */ && 
30168                                 (MATCH_w_8_16 >> 3 & 0x7) 
30169                                       /* index at 16 */ < 8)) 
30170                                 goto MATCH_label_a909;  /*opt-block+*/
30171                               else 
30172                                 goto MATCH_label_a910;  /*opt-block+*/
30173                               
30174                               break;
30175                             case 3: 
30176                               goto MATCH_label_a907; break;
30177                             default: assert(0);
30178                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30179                         break;
30180                       default: assert(0);
30181                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
30182                   
30183                   break;
30184                 case 2: 
30185                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
30186                   
30187                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
30188                       case 0: 
30189                         
30190                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30191                             case 0: 
30192                               
30193                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30194                                   case 0: case 1: case 2: case 3: case 6: 
30195                                   case 7: 
30196                                     goto MATCH_label_a911; break;
30197                                   case 4: 
30198                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30199                                     if ((MATCH_w_8_16 & 0x7) 
30200                                             /* base at 16 */ == 5 && 
30201                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30202                                             /* index at 16 */ && 
30203                                       (MATCH_w_8_16 >> 3 & 0x7) 
30204                                             /* index at 16 */ < 8)) 
30205                                       goto MATCH_label_a913;  /*opt-block+*/
30206                                     else 
30207                                       goto MATCH_label_a912;  /*opt-block+*/
30208                                     
30209                                     break;
30210                                   case 5: 
30211                                     goto MATCH_label_a914; break;
30212                                   default: assert(0);
30213                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30214                               break;
30215                             case 1: 
30216                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30217                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30218                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30219                                       /* index at 16 */ && 
30220                                 (MATCH_w_8_16 >> 3 & 0x7) 
30221                                       /* index at 16 */ < 8)) { 
30222                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
30223                                 nextPC = 4 + MATCH_p; 
30224                                 
30225                                 #line 489 "machine/pentium/disassembler.m"
30226                                 
30227 
30228                                         sprintf (str,  "ROLB.Eb.CL", DIS_EADDR8);
30229 
30230                                 
30231 
30232                                 
30233                                 
30234                                 
30235                               } /*opt-block*//*opt-block+*/
30236                               else 
30237                                 goto MATCH_label_a912;  /*opt-block+*/
30238                               
30239                               break;
30240                             case 2: 
30241                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30242                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30243                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30244                                       /* index at 16 */ && 
30245                                 (MATCH_w_8_16 >> 3 & 0x7) 
30246                                       /* index at 16 */ < 8)) 
30247                                 goto MATCH_label_a913;  /*opt-block+*/
30248                               else 
30249                                 goto MATCH_label_a914;  /*opt-block+*/
30250                               
30251                               break;
30252                             case 3: 
30253                               goto MATCH_label_a911; break;
30254                             default: assert(0);
30255                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30256                         break;
30257                       case 1: 
30258                         
30259                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30260                             case 0: 
30261                               
30262                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30263                                   case 0: case 1: case 2: case 3: case 6: 
30264                                   case 7: 
30265                                     goto MATCH_label_a915; break;
30266                                   case 4: 
30267                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30268                                     if ((MATCH_w_8_16 & 0x7) 
30269                                             /* base at 16 */ == 5 && 
30270                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30271                                             /* index at 16 */ && 
30272                                       (MATCH_w_8_16 >> 3 & 0x7) 
30273                                             /* index at 16 */ < 8)) 
30274                                       goto MATCH_label_a917;  /*opt-block+*/
30275                                     else 
30276                                       goto MATCH_label_a916;  /*opt-block+*/
30277                                     
30278                                     break;
30279                                   case 5: 
30280                                     goto MATCH_label_a918; break;
30281                                   default: assert(0);
30282                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30283                               break;
30284                             case 1: 
30285                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30286                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30287                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30288                                       /* index at 16 */ && 
30289                                 (MATCH_w_8_16 >> 3 & 0x7) 
30290                                       /* index at 16 */ < 8)) { 
30291                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
30292                                 nextPC = 4 + MATCH_p; 
30293                                 
30294                                 #line 483 "machine/pentium/disassembler.m"
30295                                 
30296 
30297                                         sprintf (str,  "RORB.Eb.CL", DIS_EADDR8);
30298 
30299                                 
30300 
30301                                 
30302                                 
30303                                 
30304                               } /*opt-block*//*opt-block+*/
30305                               else 
30306                                 goto MATCH_label_a916;  /*opt-block+*/
30307                               
30308                               break;
30309                             case 2: 
30310                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30311                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30312                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30313                                       /* index at 16 */ && 
30314                                 (MATCH_w_8_16 >> 3 & 0x7) 
30315                                       /* index at 16 */ < 8)) 
30316                                 goto MATCH_label_a917;  /*opt-block+*/
30317                               else 
30318                                 goto MATCH_label_a918;  /*opt-block+*/
30319                               
30320                               break;
30321                             case 3: 
30322                               goto MATCH_label_a915; break;
30323                             default: assert(0);
30324                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30325                         break;
30326                       case 2: 
30327                         
30328                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30329                             case 0: 
30330                               
30331                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30332                                   case 0: case 1: case 2: case 3: case 6: 
30333                                   case 7: 
30334                                     goto MATCH_label_a919; break;
30335                                   case 4: 
30336                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30337                                     if ((MATCH_w_8_16 & 0x7) 
30338                                             /* base at 16 */ == 5 && 
30339                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30340                                             /* index at 16 */ && 
30341                                       (MATCH_w_8_16 >> 3 & 0x7) 
30342                                             /* index at 16 */ < 8)) 
30343                                       goto MATCH_label_a921;  /*opt-block+*/
30344                                     else 
30345                                       goto MATCH_label_a920;  /*opt-block+*/
30346                                     
30347                                     break;
30348                                   case 5: 
30349                                     goto MATCH_label_a922; break;
30350                                   default: assert(0);
30351                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30352                               break;
30353                             case 1: 
30354                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30355                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30356                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30357                                       /* index at 16 */ && 
30358                                 (MATCH_w_8_16 >> 3 & 0x7) 
30359                                       /* index at 16 */ < 8)) { 
30360                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
30361                                 nextPC = 4 + MATCH_p; 
30362                                 
30363                                 #line 477 "machine/pentium/disassembler.m"
30364                                 
30365 
30366                                         sprintf (str,  "RCLB.Eb.CL", DIS_EADDR8);
30367 
30368                                 
30369 
30370                                 
30371                                 
30372                                 
30373                               } /*opt-block*//*opt-block+*/
30374                               else 
30375                                 goto MATCH_label_a920;  /*opt-block+*/
30376                               
30377                               break;
30378                             case 2: 
30379                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30380                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30381                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30382                                       /* index at 16 */ && 
30383                                 (MATCH_w_8_16 >> 3 & 0x7) 
30384                                       /* index at 16 */ < 8)) 
30385                                 goto MATCH_label_a921;  /*opt-block+*/
30386                               else 
30387                                 goto MATCH_label_a922;  /*opt-block+*/
30388                               
30389                               break;
30390                             case 3: 
30391                               goto MATCH_label_a919; break;
30392                             default: assert(0);
30393                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30394                         break;
30395                       case 3: 
30396                         
30397                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30398                             case 0: 
30399                               
30400                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30401                                   case 0: case 1: case 2: case 3: case 6: 
30402                                   case 7: 
30403                                     goto MATCH_label_a923; break;
30404                                   case 4: 
30405                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30406                                     if ((MATCH_w_8_16 & 0x7) 
30407                                             /* base at 16 */ == 5 && 
30408                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30409                                             /* index at 16 */ && 
30410                                       (MATCH_w_8_16 >> 3 & 0x7) 
30411                                             /* index at 16 */ < 8)) 
30412                                       goto MATCH_label_a925;  /*opt-block+*/
30413                                     else 
30414                                       goto MATCH_label_a924;  /*opt-block+*/
30415                                     
30416                                     break;
30417                                   case 5: 
30418                                     goto MATCH_label_a926; break;
30419                                   default: assert(0);
30420                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30421                               break;
30422                             case 1: 
30423                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30424                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30425                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30426                                       /* index at 16 */ && 
30427                                 (MATCH_w_8_16 >> 3 & 0x7) 
30428                                       /* index at 16 */ < 8)) { 
30429                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
30430                                 nextPC = 4 + MATCH_p; 
30431                                 
30432                                 #line 471 "machine/pentium/disassembler.m"
30433                                 
30434 
30435                                         sprintf (str,  "RCRB.Eb.CL", DIS_EADDR8);
30436 
30437                                 
30438 
30439                                 
30440                                 
30441                                 
30442                               } /*opt-block*//*opt-block+*/
30443                               else 
30444                                 goto MATCH_label_a924;  /*opt-block+*/
30445                               
30446                               break;
30447                             case 2: 
30448                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30449                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30450                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30451                                       /* index at 16 */ && 
30452                                 (MATCH_w_8_16 >> 3 & 0x7) 
30453                                       /* index at 16 */ < 8)) 
30454                                 goto MATCH_label_a925;  /*opt-block+*/
30455                               else 
30456                                 goto MATCH_label_a926;  /*opt-block+*/
30457                               
30458                               break;
30459                             case 3: 
30460                               goto MATCH_label_a923; break;
30461                             default: assert(0);
30462                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30463                         break;
30464                       case 4: 
30465                         
30466                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30467                             case 0: 
30468                               
30469                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30470                                   case 0: case 1: case 2: case 3: case 6: 
30471                                   case 7: 
30472                                     goto MATCH_label_a927; break;
30473                                   case 4: 
30474                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30475                                     if ((MATCH_w_8_16 & 0x7) 
30476                                             /* base at 16 */ == 5 && 
30477                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30478                                             /* index at 16 */ && 
30479                                       (MATCH_w_8_16 >> 3 & 0x7) 
30480                                             /* index at 16 */ < 8)) 
30481                                       goto MATCH_label_a929;  /*opt-block+*/
30482                                     else 
30483                                       goto MATCH_label_a928;  /*opt-block+*/
30484                                     
30485                                     break;
30486                                   case 5: 
30487                                     goto MATCH_label_a930; break;
30488                                   default: assert(0);
30489                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30490                               break;
30491                             case 1: 
30492                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30493                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30494                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30495                                       /* index at 16 */ && 
30496                                 (MATCH_w_8_16 >> 3 & 0x7) 
30497                                       /* index at 16 */ < 8)) { 
30498                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
30499                                 nextPC = 4 + MATCH_p; 
30500                                 
30501                                 #line 465 "machine/pentium/disassembler.m"
30502                                 
30503 
30504                                         sprintf (str,  "SHLSALB.Eb.CL", DIS_EADDR8);
30505 
30506                                 
30507 
30508                                 
30509                                 
30510                                 
30511                               } /*opt-block*//*opt-block+*/
30512                               else 
30513                                 goto MATCH_label_a928;  /*opt-block+*/
30514                               
30515                               break;
30516                             case 2: 
30517                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30518                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30519                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30520                                       /* index at 16 */ && 
30521                                 (MATCH_w_8_16 >> 3 & 0x7) 
30522                                       /* index at 16 */ < 8)) 
30523                                 goto MATCH_label_a929;  /*opt-block+*/
30524                               else 
30525                                 goto MATCH_label_a930;  /*opt-block+*/
30526                               
30527                               break;
30528                             case 3: 
30529                               goto MATCH_label_a927; break;
30530                             default: assert(0);
30531                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30532                         break;
30533                       case 5: 
30534                         
30535                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30536                             case 0: 
30537                               
30538                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30539                                   case 0: case 1: case 2: case 3: case 6: 
30540                                   case 7: 
30541                                     goto MATCH_label_a931; break;
30542                                   case 4: 
30543                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30544                                     if ((MATCH_w_8_16 & 0x7) 
30545                                             /* base at 16 */ == 5 && 
30546                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30547                                             /* index at 16 */ && 
30548                                       (MATCH_w_8_16 >> 3 & 0x7) 
30549                                             /* index at 16 */ < 8)) 
30550                                       goto MATCH_label_a933;  /*opt-block+*/
30551                                     else 
30552                                       goto MATCH_label_a932;  /*opt-block+*/
30553                                     
30554                                     break;
30555                                   case 5: 
30556                                     goto MATCH_label_a934; break;
30557                                   default: assert(0);
30558                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30559                               break;
30560                             case 1: 
30561                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30562                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30563                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30564                                       /* index at 16 */ && 
30565                                 (MATCH_w_8_16 >> 3 & 0x7) 
30566                                       /* index at 16 */ < 8)) { 
30567                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
30568                                 nextPC = 4 + MATCH_p; 
30569                                 
30570                                 #line 459 "machine/pentium/disassembler.m"
30571                                 
30572 
30573                                         sprintf (str,  "SHRB.Eb.CL", DIS_EADDR8);
30574 
30575                                 
30576 
30577                                 
30578                                 
30579                                 
30580                               } /*opt-block*//*opt-block+*/
30581                               else 
30582                                 goto MATCH_label_a932;  /*opt-block+*/
30583                               
30584                               break;
30585                             case 2: 
30586                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30587                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30588                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30589                                       /* index at 16 */ && 
30590                                 (MATCH_w_8_16 >> 3 & 0x7) 
30591                                       /* index at 16 */ < 8)) 
30592                                 goto MATCH_label_a933;  /*opt-block+*/
30593                               else 
30594                                 goto MATCH_label_a934;  /*opt-block+*/
30595                               
30596                               break;
30597                             case 3: 
30598                               goto MATCH_label_a931; break;
30599                             default: assert(0);
30600                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30601                         break;
30602                       case 6: 
30603                         goto MATCH_label_a39; break;
30604                       case 7: 
30605                         
30606                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30607                             case 0: 
30608                               
30609                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30610                                   case 0: case 1: case 2: case 3: case 6: 
30611                                   case 7: 
30612                                     goto MATCH_label_a935; break;
30613                                   case 4: 
30614                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30615                                     if ((MATCH_w_8_16 & 0x7) 
30616                                             /* base at 16 */ == 5 && 
30617                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30618                                             /* index at 16 */ && 
30619                                       (MATCH_w_8_16 >> 3 & 0x7) 
30620                                             /* index at 16 */ < 8)) 
30621                                       goto MATCH_label_a937;  /*opt-block+*/
30622                                     else 
30623                                       goto MATCH_label_a936;  /*opt-block+*/
30624                                     
30625                                     break;
30626                                   case 5: 
30627                                     goto MATCH_label_a938; break;
30628                                   default: assert(0);
30629                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30630                               break;
30631                             case 1: 
30632                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30633                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30634                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30635                                       /* index at 16 */ && 
30636                                 (MATCH_w_8_16 >> 3 & 0x7) 
30637                                       /* index at 16 */ < 8)) { 
30638                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
30639                                 nextPC = 4 + MATCH_p; 
30640                                 
30641                                 #line 453 "machine/pentium/disassembler.m"
30642                                 
30643 
30644                                         sprintf (str,  "SARB.Eb.CL", DIS_EADDR32);
30645 
30646                                 
30647 
30648                                 
30649                                 
30650                                 
30651                               } /*opt-block*//*opt-block+*/
30652                               else 
30653                                 goto MATCH_label_a936;  /*opt-block+*/
30654                               
30655                               break;
30656                             case 2: 
30657                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30658                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30659                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30660                                       /* index at 16 */ && 
30661                                 (MATCH_w_8_16 >> 3 & 0x7) 
30662                                       /* index at 16 */ < 8)) 
30663                                 goto MATCH_label_a937;  /*opt-block+*/
30664                               else 
30665                                 goto MATCH_label_a938;  /*opt-block+*/
30666                               
30667                               break;
30668                             case 3: 
30669                               goto MATCH_label_a935; break;
30670                             default: assert(0);
30671                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30672                         break;
30673                       default: assert(0);
30674                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
30675                   
30676                   break;
30677                 case 3: 
30678                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
30679                   
30680                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
30681                       case 0: 
30682                         
30683                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30684                             case 0: 
30685                               
30686                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30687                                   case 0: case 1: case 2: case 3: case 6: 
30688                                   case 7: 
30689                                     goto MATCH_label_a939; break;
30690                                   case 4: 
30691                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30692                                     if ((MATCH_w_8_16 & 0x7) 
30693                                             /* base at 16 */ == 5 && 
30694                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30695                                             /* index at 16 */ && 
30696                                       (MATCH_w_8_16 >> 3 & 0x7) 
30697                                             /* index at 16 */ < 8)) 
30698                                       goto MATCH_label_a941;  /*opt-block+*/
30699                                     else 
30700                                       goto MATCH_label_a940;  /*opt-block+*/
30701                                     
30702                                     break;
30703                                   case 5: 
30704                                     goto MATCH_label_a942; break;
30705                                   default: assert(0);
30706                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30707                               break;
30708                             case 1: 
30709                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30710                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30711                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30712                                       /* index at 16 */ && 
30713                                 (MATCH_w_8_16 >> 3 & 0x7) 
30714                                       /* index at 16 */ < 8)) { 
30715                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
30716                                 nextPC = 4 + MATCH_p; 
30717                                 
30718                                 #line 441 "machine/pentium/disassembler.m"
30719                                 
30720 
30721                                         sprintf (str,  "ROLB.Ev.CLod", DIS_EADDR32);
30722 
30723                                 
30724 
30725                                 
30726                                 
30727                                 
30728                               } /*opt-block*//*opt-block+*/
30729                               else 
30730                                 goto MATCH_label_a940;  /*opt-block+*/
30731                               
30732                               break;
30733                             case 2: 
30734                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30735                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30736                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30737                                       /* index at 16 */ && 
30738                                 (MATCH_w_8_16 >> 3 & 0x7) 
30739                                       /* index at 16 */ < 8)) 
30740                                 goto MATCH_label_a941;  /*opt-block+*/
30741                               else 
30742                                 goto MATCH_label_a942;  /*opt-block+*/
30743                               
30744                               break;
30745                             case 3: 
30746                               goto MATCH_label_a939; break;
30747                             default: assert(0);
30748                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30749                         break;
30750                       case 1: 
30751                         
30752                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30753                             case 0: 
30754                               
30755                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30756                                   case 0: case 1: case 2: case 3: case 6: 
30757                                   case 7: 
30758                                     goto MATCH_label_a943; break;
30759                                   case 4: 
30760                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30761                                     if ((MATCH_w_8_16 & 0x7) 
30762                                             /* base at 16 */ == 5 && 
30763                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30764                                             /* index at 16 */ && 
30765                                       (MATCH_w_8_16 >> 3 & 0x7) 
30766                                             /* index at 16 */ < 8)) 
30767                                       goto MATCH_label_a945;  /*opt-block+*/
30768                                     else 
30769                                       goto MATCH_label_a944;  /*opt-block+*/
30770                                     
30771                                     break;
30772                                   case 5: 
30773                                     goto MATCH_label_a946; break;
30774                                   default: assert(0);
30775                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30776                               break;
30777                             case 1: 
30778                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30779                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30780                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30781                                       /* index at 16 */ && 
30782                                 (MATCH_w_8_16 >> 3 & 0x7) 
30783                                       /* index at 16 */ < 8)) { 
30784                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
30785                                 nextPC = 4 + MATCH_p; 
30786                                 
30787                                 #line 429 "machine/pentium/disassembler.m"
30788                                 
30789 
30790                                         sprintf (str,  "RORB.Ev.CLod", DIS_EADDR32);
30791 
30792                                 
30793 
30794                                 
30795                                 
30796                                 
30797                               } /*opt-block*//*opt-block+*/
30798                               else 
30799                                 goto MATCH_label_a944;  /*opt-block+*/
30800                               
30801                               break;
30802                             case 2: 
30803                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30804                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30805                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30806                                       /* index at 16 */ && 
30807                                 (MATCH_w_8_16 >> 3 & 0x7) 
30808                                       /* index at 16 */ < 8)) 
30809                                 goto MATCH_label_a945;  /*opt-block+*/
30810                               else 
30811                                 goto MATCH_label_a946;  /*opt-block+*/
30812                               
30813                               break;
30814                             case 3: 
30815                               goto MATCH_label_a943; break;
30816                             default: assert(0);
30817                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30818                         break;
30819                       case 2: 
30820                         
30821                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30822                             case 0: 
30823                               
30824                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30825                                   case 0: case 1: case 2: case 3: case 6: 
30826                                   case 7: 
30827                                     goto MATCH_label_a947; 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                                       goto MATCH_label_a949;  /*opt-block+*/
30837                                     else 
30838                                       goto MATCH_label_a948;  /*opt-block+*/
30839                                     
30840                                     break;
30841                                   case 5: 
30842                                     goto MATCH_label_a950; break;
30843                                   default: assert(0);
30844                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30845                               break;
30846                             case 1: 
30847                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30848                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30849                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30850                                       /* index at 16 */ && 
30851                                 (MATCH_w_8_16 >> 3 & 0x7) 
30852                                       /* index at 16 */ < 8)) { 
30853                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
30854                                 nextPC = 4 + MATCH_p; 
30855                                 
30856                                 #line 417 "machine/pentium/disassembler.m"
30857                                 
30858 
30859                                         sprintf (str,  "RCLB.Ev.CLod", DIS_EADDR32);
30860 
30861                                 
30862 
30863                                 
30864                                 
30865                                 
30866                               } /*opt-block*//*opt-block+*/
30867                               else 
30868                                 goto MATCH_label_a948;  /*opt-block+*/
30869                               
30870                               break;
30871                             case 2: 
30872                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30873                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30874                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30875                                       /* index at 16 */ && 
30876                                 (MATCH_w_8_16 >> 3 & 0x7) 
30877                                       /* index at 16 */ < 8)) 
30878                                 goto MATCH_label_a949;  /*opt-block+*/
30879                               else 
30880                                 goto MATCH_label_a950;  /*opt-block+*/
30881                               
30882                               break;
30883                             case 3: 
30884                               goto MATCH_label_a947; break;
30885                             default: assert(0);
30886                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30887                         break;
30888                       case 3: 
30889                         
30890                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30891                             case 0: 
30892                               
30893                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30894                                   case 0: case 1: case 2: case 3: case 6: 
30895                                   case 7: 
30896                                     goto MATCH_label_a951; break;
30897                                   case 4: 
30898                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30899                                     if ((MATCH_w_8_16 & 0x7) 
30900                                             /* base at 16 */ == 5 && 
30901                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30902                                             /* index at 16 */ && 
30903                                       (MATCH_w_8_16 >> 3 & 0x7) 
30904                                             /* index at 16 */ < 8)) 
30905                                       goto MATCH_label_a953;  /*opt-block+*/
30906                                     else 
30907                                       goto MATCH_label_a952;  /*opt-block+*/
30908                                     
30909                                     break;
30910                                   case 5: 
30911                                     goto MATCH_label_a954; break;
30912                                   default: assert(0);
30913                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30914                               break;
30915                             case 1: 
30916                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30917                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30918                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30919                                       /* index at 16 */ && 
30920                                 (MATCH_w_8_16 >> 3 & 0x7) 
30921                                       /* index at 16 */ < 8)) { 
30922                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
30923                                 nextPC = 4 + MATCH_p; 
30924                                 
30925                                 #line 405 "machine/pentium/disassembler.m"
30926                                 
30927 
30928                                         sprintf (str,  "RCRB.Ev.CLod", DIS_EADDR32);
30929 
30930                                 
30931 
30932                                 
30933                                 
30934                                 
30935                               } /*opt-block*//*opt-block+*/
30936                               else 
30937                                 goto MATCH_label_a952;  /*opt-block+*/
30938                               
30939                               break;
30940                             case 2: 
30941                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30942                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30943                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30944                                       /* index at 16 */ && 
30945                                 (MATCH_w_8_16 >> 3 & 0x7) 
30946                                       /* index at 16 */ < 8)) 
30947                                 goto MATCH_label_a953;  /*opt-block+*/
30948                               else 
30949                                 goto MATCH_label_a954;  /*opt-block+*/
30950                               
30951                               break;
30952                             case 3: 
30953                               goto MATCH_label_a951; break;
30954                             default: assert(0);
30955                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
30956                         break;
30957                       case 4: 
30958                         
30959                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
30960                             case 0: 
30961                               
30962                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
30963                                   case 0: case 1: case 2: case 3: case 6: 
30964                                   case 7: 
30965                                     goto MATCH_label_a955; break;
30966                                   case 4: 
30967                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
30968                                     if ((MATCH_w_8_16 & 0x7) 
30969                                             /* base at 16 */ == 5 && 
30970                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30971                                             /* index at 16 */ && 
30972                                       (MATCH_w_8_16 >> 3 & 0x7) 
30973                                             /* index at 16 */ < 8)) 
30974                                       goto MATCH_label_a957;  /*opt-block+*/
30975                                     else 
30976                                       goto MATCH_label_a956;  /*opt-block+*/
30977                                     
30978                                     break;
30979                                   case 5: 
30980                                     goto MATCH_label_a958; break;
30981                                   default: assert(0);
30982                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
30983                               break;
30984                             case 1: 
30985                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
30986                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
30987                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
30988                                       /* index at 16 */ && 
30989                                 (MATCH_w_8_16 >> 3 & 0x7) 
30990                                       /* index at 16 */ < 8)) { 
30991                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
30992                                 nextPC = 4 + MATCH_p; 
30993                                 
30994                                 #line 393 "machine/pentium/disassembler.m"
30995                                 
30996 
30997                                         sprintf (str,  "SHLSALB.Ev.CLod", DIS_EADDR32);
30998 
30999                                 
31000 
31001                                 
31002                                 
31003                                 
31004                               } /*opt-block*//*opt-block+*/
31005                               else 
31006                                 goto MATCH_label_a956;  /*opt-block+*/
31007                               
31008                               break;
31009                             case 2: 
31010                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31011                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31012                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31013                                       /* index at 16 */ && 
31014                                 (MATCH_w_8_16 >> 3 & 0x7) 
31015                                       /* index at 16 */ < 8)) 
31016                                 goto MATCH_label_a957;  /*opt-block+*/
31017                               else 
31018                                 goto MATCH_label_a958;  /*opt-block+*/
31019                               
31020                               break;
31021                             case 3: 
31022                               goto MATCH_label_a955; break;
31023                             default: assert(0);
31024                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
31025                         break;
31026                       case 5: 
31027                         
31028                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
31029                             case 0: 
31030                               
31031                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
31032                                   case 0: case 1: case 2: case 3: case 6: 
31033                                   case 7: 
31034                                     goto MATCH_label_a959; break;
31035                                   case 4: 
31036                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31037                                     if ((MATCH_w_8_16 & 0x7) 
31038                                             /* base at 16 */ == 5 && 
31039                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31040                                             /* index at 16 */ && 
31041                                       (MATCH_w_8_16 >> 3 & 0x7) 
31042                                             /* index at 16 */ < 8)) 
31043                                       goto MATCH_label_a961;  /*opt-block+*/
31044                                     else 
31045                                       goto MATCH_label_a960;  /*opt-block+*/
31046                                     
31047                                     break;
31048                                   case 5: 
31049                                     goto MATCH_label_a962; break;
31050                                   default: assert(0);
31051                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
31052                               break;
31053                             case 1: 
31054                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31055                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31056                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31057                                       /* index at 16 */ && 
31058                                 (MATCH_w_8_16 >> 3 & 0x7) 
31059                                       /* index at 16 */ < 8)) { 
31060                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
31061                                 nextPC = 4 + MATCH_p; 
31062                                 
31063                                 #line 381 "machine/pentium/disassembler.m"
31064                                 
31065 
31066                                         sprintf (str,  "SHRB.Ev.CLod", DIS_EADDR32);
31067 
31068                                 
31069 
31070                                 
31071                                 
31072                                 
31073                               } /*opt-block*//*opt-block+*/
31074                               else 
31075                                 goto MATCH_label_a960;  /*opt-block+*/
31076                               
31077                               break;
31078                             case 2: 
31079                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31080                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31081                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31082                                       /* index at 16 */ && 
31083                                 (MATCH_w_8_16 >> 3 & 0x7) 
31084                                       /* index at 16 */ < 8)) 
31085                                 goto MATCH_label_a961;  /*opt-block+*/
31086                               else 
31087                                 goto MATCH_label_a962;  /*opt-block+*/
31088                               
31089                               break;
31090                             case 3: 
31091                               goto MATCH_label_a959; break;
31092                             default: assert(0);
31093                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
31094                         break;
31095                       case 6: 
31096                         goto MATCH_label_a39; break;
31097                       case 7: 
31098                         
31099                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
31100                             case 0: 
31101                               
31102                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
31103                                   case 0: case 1: case 2: case 3: case 6: 
31104                                   case 7: 
31105                                     goto MATCH_label_a963; break;
31106                                   case 4: 
31107                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31108                                     if ((MATCH_w_8_16 & 0x7) 
31109                                             /* base at 16 */ == 5 && 
31110                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31111                                             /* index at 16 */ && 
31112                                       (MATCH_w_8_16 >> 3 & 0x7) 
31113                                             /* index at 16 */ < 8)) 
31114                                       goto MATCH_label_a965;  /*opt-block+*/
31115                                     else 
31116                                       goto MATCH_label_a964;  /*opt-block+*/
31117                                     
31118                                     break;
31119                                   case 5: 
31120                                     goto MATCH_label_a966; break;
31121                                   default: assert(0);
31122                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
31123                               break;
31124                             case 1: 
31125                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31126                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31127                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31128                                       /* index at 16 */ && 
31129                                 (MATCH_w_8_16 >> 3 & 0x7) 
31130                                       /* index at 16 */ < 8)) { 
31131                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
31132                                 nextPC = 4 + MATCH_p; 
31133                                 
31134                                 #line 369 "machine/pentium/disassembler.m"
31135                                 
31136 
31137                                         sprintf (str,  "SARB.Ev.CLod", DIS_EADDR32);
31138 
31139                                 
31140 
31141                                 
31142                                 
31143                                 
31144                               } /*opt-block*//*opt-block+*/
31145                               else 
31146                                 goto MATCH_label_a964;  /*opt-block+*/
31147                               
31148                               break;
31149                             case 2: 
31150                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31151                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31152                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31153                                       /* index at 16 */ && 
31154                                 (MATCH_w_8_16 >> 3 & 0x7) 
31155                                       /* index at 16 */ < 8)) 
31156                                 goto MATCH_label_a965;  /*opt-block+*/
31157                               else 
31158                                 goto MATCH_label_a966;  /*opt-block+*/
31159                               
31160                               break;
31161                             case 3: 
31162                               goto MATCH_label_a963; break;
31163                             default: assert(0);
31164                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
31165                         break;
31166                       default: assert(0);
31167                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
31168                   
31169                   break;
31170                 case 4: case 5: case 6: 
31171                   goto MATCH_label_a39; break;
31172                 case 7: 
31173                   nextPC = 1 + MATCH_p; 
31174                   
31175                   #line 44 "machine/pentium/disassembler.m"
31176                   
31177 
31178                           sprintf (str, "%s", "XLATB");
31179 
31180                   
31181 
31182                   
31183                   
31184                   
31185                   
31186                   break;
31187                 default: assert(0);
31188               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/  
31189           break;
31190         case 14: 
31191           
31192             switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
31193               case 0: 
31194                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) { 
31195                   MATCH_w_32_8 = getDword(1 + MATCH_p); 
31196                   MATCH_name = MATCH_name_page_0[(MATCH_w_8_0 >> 3 & 0x1) 
31197                         /* page at 0 */]; 
31198                   { 
31199                     char *name = MATCH_name;
31200                     unsigned relocd = 
31201                       5 + MATCH_w_32_8 /* i32 at 8 */ + addressToPC(MATCH_p);
31202                     nextPC = 5 + MATCH_p; 
31203                     
31204                     #line 986 "machine/pentium/disassembler.m"
31205                     
31206 
31207                             sprintf (str,  name, dis_Num(relocd-hostPC-5));
31208 
31209                     
31210 
31211                     
31212                     
31213                     
31214                   }
31215                   
31216                 } /*opt-block*/
31217                 else { 
31218                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
31219                   { 
31220                     unsigned relocd = 
31221                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
31222                                   8) + addressToPC(MATCH_p);
31223                     nextPC = 2 + MATCH_p; 
31224                     
31225                     #line 757 "machine/pentium/disassembler.m"
31226                     
31227 
31228                             sprintf (str,  "LOOPNE", dis_Num(relocd - hostPC - 2));
31229 
31230                     
31231 
31232                     
31233                     
31234                     
31235                   }
31236                   
31237                 } /*opt-block*/
31238                 
31239                 break;
31240               case 1: 
31241                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 0) { 
31242                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
31243                   { 
31244                     unsigned relocd = 
31245                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
31246                                   8) + addressToPC(MATCH_p);
31247                     nextPC = 2 + MATCH_p; 
31248                     
31249                     #line 760 "machine/pentium/disassembler.m"
31250                     
31251 
31252                             sprintf (str,  "LOOPE", dis_Num(relocd-hostPC-2));
31253 
31254                     
31255 
31256                     
31257                     
31258                     
31259                   }
31260                   
31261                 } /*opt-block*/
31262                 else 
31263                   goto MATCH_label_a39;  /*opt-block+*/
31264                 
31265                 break;
31266               case 2: 
31267                 if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 0) { 
31268                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
31269                   { 
31270                     unsigned relocd = 
31271                       2 + sign_extend((MATCH_w_8_8 & 0xff) /* i8 at 8 */, 
31272                                   8) + addressToPC(MATCH_p);
31273                     nextPC = 2 + MATCH_p; 
31274                     
31275                     #line 763 "machine/pentium/disassembler.m"
31276                     
31277 
31278                             sprintf (str,  "LOOP", dis_Num(relocd-hostPC-2));
31279 
31280                     
31281 
31282                     
31283                     
31284                     
31285                   }
31286                   
31287                 } /*opt-block*/
31288                 else 
31289                   goto MATCH_label_a39;  /*opt-block+*/
31290                 
31291                 break;
31292               case 3: case 4: case 5: case 6: case 7: 
31293                 goto MATCH_label_a39; break;
31294               default: assert(0);
31295             } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/ 
31296           break;
31297         case 15: 
31298           if ((MATCH_w_8_0 >> 3 & 0x1) /* page at 0 */ == 1) 
31299             
31300               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
31301                 case 0: 
31302                   nextPC = 1 + MATCH_p; 
31303                   
31304                   #line 971 "machine/pentium/disassembler.m"
31305                   
31306 
31307                           sprintf (str,  "CLC");
31308 
31309                   
31310 
31311                   
31312                   
31313                   
31314                   
31315                   break;
31316                 case 1: 
31317                   nextPC = 1 + MATCH_p; 
31318                   
31319                   #line 140 "machine/pentium/disassembler.m"
31320                   
31321 
31322                           sprintf (str,  "STC");
31323 
31324                   
31325 
31326                   
31327                   
31328                   
31329                   
31330                   break;
31331                 case 2: 
31332                   nextPC = 1 + MATCH_p; 
31333                   
31334                   #line 965 "machine/pentium/disassembler.m"
31335                   
31336 
31337                           sprintf (str,  "CLI");
31338 
31339                   
31340 
31341                   
31342                   
31343                   
31344                   
31345                   break;
31346                 case 3: 
31347                   nextPC = 1 + MATCH_p; 
31348                   
31349                   #line 134 "machine/pentium/disassembler.m"
31350                   
31351 
31352                           sprintf (str,  "STI");
31353 
31354                   
31355 
31356                   
31357                   
31358                   
31359                   
31360                   break;
31361                 case 4: 
31362                   nextPC = 1 + MATCH_p; 
31363                   
31364                   #line 968 "machine/pentium/disassembler.m"
31365                   
31366 
31367                           sprintf (str,  "CLD");
31368 
31369                   
31370 
31371                   
31372                   
31373                   
31374                   
31375                   break;
31376                 case 5: 
31377                   nextPC = 1 + MATCH_p; 
31378                   
31379                   #line 137 "machine/pentium/disassembler.m"
31380                   
31381 
31382                           sprintf (str,  "STD");
31383 
31384                   
31385 
31386                   
31387                   
31388                   
31389                   
31390                   break;
31391                 case 6: 
31392                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
31393                   
31394                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
31395                       case 0: 
31396                         
31397                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
31398                             case 0: 
31399                               
31400                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
31401                                   case 0: case 1: case 2: case 3: case 6: 
31402                                   case 7: 
31403                                     goto MATCH_label_a1194; break;
31404                                   case 4: 
31405                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31406                                     if ((MATCH_w_8_16 & 0x7) 
31407                                             /* base at 16 */ == 5 && 
31408                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31409                                             /* index at 16 */ && 
31410                                       (MATCH_w_8_16 >> 3 & 0x7) 
31411                                             /* index at 16 */ < 8)) 
31412                                       goto MATCH_label_a1196;  /*opt-block+*/
31413                                     else 
31414                                       goto MATCH_label_a1195;  /*opt-block+*/
31415                                     
31416                                     break;
31417                                   case 5: 
31418                                     goto MATCH_label_a1197; break;
31419                                   default: assert(0);
31420                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
31421                               break;
31422                             case 1: 
31423                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31424                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31425                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31426                                       /* index at 16 */ && 
31427                                 (MATCH_w_8_16 >> 3 & 0x7) 
31428                                       /* index at 16 */ < 8)) { 
31429                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
31430                                 nextPC = 4 + MATCH_p; 
31431                                 
31432                                 #line 836 "machine/pentium/disassembler.m"
31433                                 
31434 
31435                                         sprintf (str,  "INC.Eb", DIS_EADDR8);
31436 
31437                                 
31438 
31439                                 //    | IN.eAX.DXod() =>
31440 
31441                                 //        sprintf (str,  "IN.eAX.DXod");
31442 
31443                                 
31444 
31445                                 //    | IN.eAX.DXow() =>
31446 
31447                                 //        sprintf (str,  "IN.eAX.DXow");
31448 
31449                                 
31450 
31451                                 //    | IN.AL.DX() =>
31452 
31453                                 //        sprintf (str,  "IN.AL.DX");
31454 
31455                                 
31456 
31457                                 //    | IN.eAX.Ibod(i8) =>
31458 
31459                                 //        sprintf (str,  "IN.eAX.Ibod", DIS_I8);
31460 
31461                                 
31462 
31463                                 //    | IN.eAX.Ibow(i8) =>
31464 
31465                                 //        sprintf (str,  "IN.eAX.Ibow", DIS_I8);
31466 
31467                                 
31468 
31469                                 //    | IN.AL.Ib(i8) =>
31470 
31471                                 //        sprintf (str,  "IN.AL.Ib", DIS_I8);
31472 
31473                                 
31474 
31475                                 
31476                                 
31477                                 
31478                               } /*opt-block*//*opt-block+*/
31479                               else 
31480                                 goto MATCH_label_a1195;  /*opt-block+*/
31481                               
31482                               break;
31483                             case 2: 
31484                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31485                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31486                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31487                                       /* index at 16 */ && 
31488                                 (MATCH_w_8_16 >> 3 & 0x7) 
31489                                       /* index at 16 */ < 8)) 
31490                                 goto MATCH_label_a1196;  /*opt-block+*/
31491                               else 
31492                                 goto MATCH_label_a1197;  /*opt-block+*/
31493                               
31494                               break;
31495                             case 3: 
31496                               goto MATCH_label_a1194; break;
31497                             default: assert(0);
31498                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
31499                         break;
31500                       case 1: 
31501                         
31502                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
31503                             case 0: 
31504                               
31505                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
31506                                   case 0: case 1: case 2: case 3: case 6: 
31507                                   case 7: 
31508                                     goto MATCH_label_a1198; break;
31509                                   case 4: 
31510                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31511                                     if ((MATCH_w_8_16 & 0x7) 
31512                                             /* base at 16 */ == 5 && 
31513                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31514                                             /* index at 16 */ && 
31515                                       (MATCH_w_8_16 >> 3 & 0x7) 
31516                                             /* index at 16 */ < 8)) 
31517                                       goto MATCH_label_a1200;  /*opt-block+*/
31518                                     else 
31519                                       goto MATCH_label_a1199;  /*opt-block+*/
31520                                     
31521                                     break;
31522                                   case 5: 
31523                                     goto MATCH_label_a1201; break;
31524                                   default: assert(0);
31525                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
31526                               break;
31527                             case 1: 
31528                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31529                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31530                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31531                                       /* index at 16 */ && 
31532                                 (MATCH_w_8_16 >> 3 & 0x7) 
31533                                       /* index at 16 */ < 8)) { 
31534                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
31535                                 nextPC = 4 + MATCH_p; 
31536                                 
31537                                 #line 920 "machine/pentium/disassembler.m"
31538                                 
31539 
31540                                         sprintf (str,  "DEC.Eb", DIS_EADDR8);
31541 
31542                                 
31543 
31544                                 
31545                                 
31546                                 
31547                               } /*opt-block*//*opt-block+*/
31548                               else 
31549                                 goto MATCH_label_a1199;  /*opt-block+*/
31550                               
31551                               break;
31552                             case 2: 
31553                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31554                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31555                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31556                                       /* index at 16 */ && 
31557                                 (MATCH_w_8_16 >> 3 & 0x7) 
31558                                       /* index at 16 */ < 8)) 
31559                                 goto MATCH_label_a1200;  /*opt-block+*/
31560                               else 
31561                                 goto MATCH_label_a1201;  /*opt-block+*/
31562                               
31563                               break;
31564                             case 3: 
31565                               goto MATCH_label_a1198; break;
31566                             default: assert(0);
31567                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
31568                         break;
31569                       case 2: case 3: case 4: case 5: case 6: case 7: 
31570                         goto MATCH_label_a39; break;
31571                       default: assert(0);
31572                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
31573                   
31574                   break;
31575                 case 7: 
31576                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
31577                   
31578                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
31579                       case 0: 
31580                         
31581                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
31582                             case 0: 
31583                               
31584                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
31585                                   case 0: case 1: case 2: case 3: case 6: 
31586                                   case 7: 
31587                                     goto MATCH_label_a1202; break;
31588                                   case 4: 
31589                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31590                                     if ((MATCH_w_8_16 & 0x7) 
31591                                             /* base at 16 */ == 5 && 
31592                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31593                                             /* index at 16 */ && 
31594                                       (MATCH_w_8_16 >> 3 & 0x7) 
31595                                             /* index at 16 */ < 8)) 
31596                                       goto MATCH_label_a1204;  /*opt-block+*/
31597                                     else 
31598                                       goto MATCH_label_a1203;  /*opt-block+*/
31599                                     
31600                                     break;
31601                                   case 5: 
31602                                     goto MATCH_label_a1205; break;
31603                                   default: assert(0);
31604                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
31605                               break;
31606                             case 1: 
31607                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31608                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31609                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31610                                       /* index at 16 */ && 
31611                                 (MATCH_w_8_16 >> 3 & 0x7) 
31612                                       /* index at 16 */ < 8)) { 
31613                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
31614                                 nextPC = 4 + MATCH_p; 
31615                                 
31616                                 #line 830 "machine/pentium/disassembler.m"
31617                                 
31618 
31619                                         sprintf (str,  "INC.Evod", DIS_EADDR32);
31620 
31621                                 
31622 
31623                                 
31624                                 
31625                                 
31626                               } /*opt-block*//*opt-block+*/
31627                               else 
31628                                 goto MATCH_label_a1203;  /*opt-block+*/
31629                               
31630                               break;
31631                             case 2: 
31632                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31633                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31634                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31635                                       /* index at 16 */ && 
31636                                 (MATCH_w_8_16 >> 3 & 0x7) 
31637                                       /* index at 16 */ < 8)) 
31638                                 goto MATCH_label_a1204;  /*opt-block+*/
31639                               else 
31640                                 goto MATCH_label_a1205;  /*opt-block+*/
31641                               
31642                               break;
31643                             case 3: 
31644                               goto MATCH_label_a1202; break;
31645                             default: assert(0);
31646                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
31647                         break;
31648                       case 1: 
31649                         
31650                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
31651                             case 0: 
31652                               
31653                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
31654                                   case 0: case 1: case 2: case 3: case 6: 
31655                                   case 7: 
31656                                     goto MATCH_label_a1206; break;
31657                                   case 4: 
31658                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31659                                     if ((MATCH_w_8_16 & 0x7) 
31660                                             /* base at 16 */ == 5 && 
31661                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31662                                             /* index at 16 */ && 
31663                                       (MATCH_w_8_16 >> 3 & 0x7) 
31664                                             /* index at 16 */ < 8)) 
31665                                       goto MATCH_label_a1208;  /*opt-block+*/
31666                                     else 
31667                                       goto MATCH_label_a1207;  /*opt-block+*/
31668                                     
31669                                     break;
31670                                   case 5: 
31671                                     goto MATCH_label_a1209; break;
31672                                   default: assert(0);
31673                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
31674                               break;
31675                             case 1: 
31676                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31677                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31678                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31679                                       /* index at 16 */ && 
31680                                 (MATCH_w_8_16 >> 3 & 0x7) 
31681                                       /* index at 16 */ < 8)) { 
31682                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
31683                                 nextPC = 4 + MATCH_p; 
31684                                 
31685                                 #line 914 "machine/pentium/disassembler.m"
31686                                 
31687 
31688                                         sprintf (str,  "DEC.Evod", DIS_EADDR32);
31689 
31690                                 
31691 
31692                                 
31693                                 
31694                                 
31695                               } /*opt-block*//*opt-block+*/
31696                               else 
31697                                 goto MATCH_label_a1207;  /*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                                 goto MATCH_label_a1208;  /*opt-block+*/
31708                               else 
31709                                 goto MATCH_label_a1209;  /*opt-block+*/
31710                               
31711                               break;
31712                             case 3: 
31713                               goto MATCH_label_a1206; break;
31714                             default: assert(0);
31715                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
31716                         break;
31717                       case 2: 
31718                         
31719                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
31720                             case 0: 
31721                               
31722                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
31723                                   case 0: case 1: case 2: case 3: case 6: 
31724                                   case 7: 
31725                                     goto MATCH_label_a1210; break;
31726                                   case 4: 
31727                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31728                                     if ((MATCH_w_8_16 & 0x7) 
31729                                             /* base at 16 */ == 5 && 
31730                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31731                                             /* index at 16 */ && 
31732                                       (MATCH_w_8_16 >> 3 & 0x7) 
31733                                             /* index at 16 */ < 8)) 
31734                                       goto MATCH_label_a1212;  /*opt-block+*/
31735                                     else 
31736                                       goto MATCH_label_a1211;  /*opt-block+*/
31737                                     
31738                                     break;
31739                                   case 5: 
31740                                     goto MATCH_label_a1213; break;
31741                                   default: assert(0);
31742                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
31743                               break;
31744                             case 1: 
31745                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31746                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31747                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31748                                       /* index at 16 */ && 
31749                                 (MATCH_w_8_16 >> 3 & 0x7) 
31750                                       /* index at 16 */ < 8)) { 
31751                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
31752                                 nextPC = 4 + MATCH_p; 
31753                                 
31754                                 #line 989 "machine/pentium/disassembler.m"
31755                                 
31756 
31757                                         sprintf (str,  "CALL.Evod", DIS_EADDR32);
31758 
31759                                 
31760 
31761                                 
31762                                 
31763                                 
31764                               } /*opt-block*//*opt-block+*/
31765                               else 
31766                                 goto MATCH_label_a1211;  /*opt-block+*/
31767                               
31768                               break;
31769                             case 2: 
31770                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31771                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31772                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31773                                       /* index at 16 */ && 
31774                                 (MATCH_w_8_16 >> 3 & 0x7) 
31775                                       /* index at 16 */ < 8)) 
31776                                 goto MATCH_label_a1212;  /*opt-block+*/
31777                               else 
31778                                 goto MATCH_label_a1213;  /*opt-block+*/
31779                               
31780                               break;
31781                             case 3: 
31782                               goto MATCH_label_a1210; break;
31783                             default: assert(0);
31784                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
31785                         break;
31786                       case 3: case 4: case 5: case 7: 
31787                         goto MATCH_label_a39; break;
31788                       case 6: 
31789                         
31790                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
31791                             case 0: 
31792                               
31793                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
31794                                   case 0: case 1: case 2: case 3: case 6: 
31795                                   case 7: 
31796                                     goto MATCH_label_a1214; break;
31797                                   case 4: 
31798                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
31799                                     if ((MATCH_w_8_16 & 0x7) 
31800                                             /* base at 16 */ == 5 && 
31801                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31802                                             /* index at 16 */ && 
31803                                       (MATCH_w_8_16 >> 3 & 0x7) 
31804                                             /* index at 16 */ < 8)) 
31805                                       goto MATCH_label_a1216;  /*opt-block+*/
31806                                     else 
31807                                       goto MATCH_label_a1215;  /*opt-block+*/
31808                                     
31809                                     break;
31810                                   case 5: 
31811                                     goto MATCH_label_a1217; break;
31812                                   default: assert(0);
31813                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
31814                               break;
31815                             case 1: 
31816                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31817                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31818                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31819                                       /* index at 16 */ && 
31820                                 (MATCH_w_8_16 >> 3 & 0x7) 
31821                                       /* index at 16 */ < 8)) { 
31822                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
31823                                 nextPC = 4 + MATCH_p; 
31824                                 
31825                                 #line 543 "machine/pentium/disassembler.m"
31826                                 
31827 
31828                                         sprintf (str,  "PUSH.Evod", DIS_EADDR32);
31829 
31830                                 
31831 
31832                                 
31833                                 
31834                                 
31835                               } /*opt-block*//*opt-block+*/
31836                               else 
31837                                 goto MATCH_label_a1215;  /*opt-block+*/
31838                               
31839                               break;
31840                             case 2: 
31841                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
31842                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
31843                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
31844                                       /* index at 16 */ && 
31845                                 (MATCH_w_8_16 >> 3 & 0x7) 
31846                                       /* index at 16 */ < 8)) 
31847                                 goto MATCH_label_a1216;  /*opt-block+*/
31848                               else 
31849                                 goto MATCH_label_a1217;  /*opt-block+*/
31850                               
31851                               break;
31852                             case 3: 
31853                               goto MATCH_label_a1214; break;
31854                             default: assert(0);
31855                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
31856                         break;
31857                       default: assert(0);
31858                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
31859                   
31860                   break;
31861                 default: assert(0);
31862               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/  
31863           else 
31864             
31865               switch((MATCH_w_8_0 & 0x7) /* col at 0 */) {
31866                 case 0: case 1: case 4: 
31867                   goto MATCH_label_a39; break;
31868                 case 2: 
31869                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
31870                   
31871                     switch((MATCH_w_8_8 >> 4 & 0xf) /* row at 8 */) {
31872                       case 0: case 1: case 2: case 3: case 4: case 5: case 7: 
31873                       case 8: case 9: case 11: case 12: case 13: case 14: 
31874                       case 15: 
31875                         goto MATCH_label_a39; break;
31876                       case 6: 
31877                         if ((MATCH_w_8_8 & 0x7) /* col at 8 */ == 6) 
31878                           if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) 
31879                             goto MATCH_label_a39;  /*opt-block+*/
31880                           else { 
31881                             MATCH_w_8_16 = getByte(2 + MATCH_p); 
31882                             
31883                               switch((MATCH_w_8_16 & 0x7) /* col at 16 */) {
31884                                 case 0: case 1: case 2: case 4: case 6: 
31885                                   goto MATCH_label_a39; break;
31886                                 case 3: 
31887                                   if ((MATCH_w_8_16 >> 4 & 0xf) 
31888                                           /* row at 16 */ == 10 && 
31889                                     (MATCH_w_8_16 >> 3 & 0x1) 
31890                                           /* page at 16 */ == 1) { 
31891                                     MATCH_name = 
31892                                       MATCH_name_page_6[(MATCH_w_8_16 >> 3 & 0x1) 
31893                                           /* page at 16 */]; 
31894                                     { 
31895                                       char *name = MATCH_name;
31896                                       nextPC = 3 + MATCH_p; 
31897                                       
31898                                       #line 297 "machine/pentium/disassembler.m"
31899                                       
31900 
31901                                               sprintf (str,  name);
31902 
31903                                       
31904 
31905                                       
31906                                       
31907                                       
31908                                     }
31909                                     
31910                                   } /*opt-block*/
31911                                   else 
31912                                     goto MATCH_label_a39;  /*opt-block+*/
31913                                   
31914                                   break;
31915                                 case 5: 
31916                                   if ((MATCH_w_8_16 >> 4 & 0xf) 
31917                                           /* row at 16 */ == 10) 
31918                                     if ((MATCH_w_8_16 >> 3 & 0x1) 
31919                                             /* page at 16 */ == 1) { 
31920                                       MATCH_name = 
31921                                         MATCH_name_page_7[(MATCH_w_8_16 >> 3 & 0x1) 
31922                                             /* page at 16 */]; 
31923                                       { 
31924                                         char *name = MATCH_name;
31925                                         nextPC = 3 + MATCH_p; 
31926                                         
31927                                         #line 270 "machine/pentium/disassembler.m"
31928                                         
31929 
31930                                                 sprintf (str,  name);
31931 
31932                                         
31933 
31934                                         
31935                                         
31936                                         
31937                                       }
31938                                       
31939                                     } /*opt-block*/
31940                                     else { 
31941                                       MATCH_name = 
31942                                         MATCH_name_page_6[(MATCH_w_8_16 >> 3 & 0x1) 
31943                                             /* page at 16 */]; 
31944                                       { 
31945                                         char *name = MATCH_name;
31946                                         nextPC = 3 + MATCH_p; 
31947                                         
31948                                         #line 279 "machine/pentium/disassembler.m"
31949                                         
31950 
31951                                                 sprintf (str,  name);
31952 
31953                                         
31954 
31955                                         
31956                                         
31957                                         
31958                                       }
31959                                       
31960                                     } /*opt-block*/ /*opt-block+*/
31961                                   else 
31962                                     goto MATCH_label_a39;  /*opt-block+*/
31963                                   break;
31964                                 case 7: 
31965                                   if ((MATCH_w_8_16 >> 4 & 0xf) 
31966                                           /* row at 16 */ == 10) 
31967                                     if ((MATCH_w_8_16 >> 3 & 0x1) 
31968                                             /* page at 16 */ == 1) { 
31969                                       MATCH_name = 
31970                                         MATCH_name_page_8[(MATCH_w_8_16 >> 3 & 0x1) 
31971                                             /* page at 16 */]; 
31972                                       { 
31973                                         char *name = MATCH_name;
31974                                         nextPC = 3 + MATCH_p; 
31975                                         
31976                                         #line 288 "machine/pentium/disassembler.m"
31977                                         
31978 
31979                                                 sprintf (str,  name);
31980 
31981                                         
31982 
31983                                         
31984                                         
31985                                         
31986                                       }
31987                                       
31988                                     } /*opt-block*/
31989                                     else { 
31990                                       MATCH_name = 
31991                                         MATCH_name_page_7[(MATCH_w_8_16 >> 3 & 0x1) 
31992                                             /* page at 16 */]; 
31993                                       { 
31994                                         char *name = MATCH_name;
31995                                         nextPC = 3 + MATCH_p; 
31996                                         
31997                                         #line 261 "machine/pentium/disassembler.m"
31998                                         
31999 
32000                                                 sprintf (str,  name);
32001 
32002                                         
32003 
32004                                         
32005                                         
32006                                         
32007                                       }
32008                                       
32009                                     } /*opt-block*/ /*opt-block+*/
32010                                   else 
32011                                     goto MATCH_label_a39;  /*opt-block+*/
32012                                   break;
32013                                 default: assert(0);
32014                               } /* (MATCH_w_8_16 & 0x7) -- col at 16 --*/ 
32015                             
32016                           } /*opt-block*/ 
32017                         else 
32018                           goto MATCH_label_a39;  /*opt-block+*/
32019                         break;
32020                       case 10: 
32021                         
32022                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
32023                             case 0: case 1: 
32024                               goto MATCH_label_a39; break;
32025                             case 2: 
32026                               if ((MATCH_w_8_8 >> 3 & 0x1) 
32027                                       /* page at 8 */ == 1) { 
32028                                 MATCH_name = 
32029                                   MATCH_name_page_9[(MATCH_w_8_8 >> 3 & 0x1) 
32030                                       /* page at 8 */]; 
32031                                 { 
32032                                   char *name = MATCH_name;
32033                                   nextPC = 2 + MATCH_p; 
32034                                   
32035                                   #line 294 "machine/pentium/disassembler.m"
32036                                   
32037 
32038                                           sprintf (str,  name);
32039 
32040                                   
32041 
32042                                   
32043                                   
32044                                   
32045                                 }
32046                                 
32047                               } /*opt-block*/
32048                               else 
32049                                 goto MATCH_label_a39;  /*opt-block+*/
32050                               
32051                               break;
32052                             case 3: 
32053                               if ((MATCH_w_8_8 >> 3 & 0x1) 
32054                                       /* page at 8 */ == 1) { 
32055                                 MATCH_name = 
32056                                   MATCH_name_page_10[(MATCH_w_8_8 >> 3 & 0x1) 
32057                                       /* page at 8 */]; 
32058                                 { 
32059                                   char *name = MATCH_name;
32060                                   nextPC = 2 + MATCH_p; 
32061                                   
32062                                   #line 300 "machine/pentium/disassembler.m"
32063                                   
32064 
32065                                           sprintf (str,  name);
32066 
32067                                   
32068 
32069                                   
32070                                   
32071                                   
32072                                 }
32073                                 
32074                               } /*opt-block*/
32075                               else 
32076                                 goto MATCH_label_a39;  /*opt-block+*/
32077                               
32078                               break;
32079                             case 4: 
32080                               if ((MATCH_w_8_8 >> 3 & 0x1) 
32081                                       /* page at 8 */ == 1) { 
32082                                 MATCH_name = 
32083                                   MATCH_name_page_11[(MATCH_w_8_8 >> 3 & 0x1) 
32084                                       /* page at 8 */]; 
32085                                 { 
32086                                   char *name = MATCH_name;
32087                                   nextPC = 2 + MATCH_p; 
32088                                   
32089                                   #line 267 "machine/pentium/disassembler.m"
32090                                   
32091 
32092                                           sprintf (str,  name);
32093 
32094                                   
32095 
32096                                   
32097                                   
32098                                   
32099                                 }
32100                                 
32101                               } /*opt-block*/
32102                               else { 
32103                                 MATCH_name = 
32104                                   MATCH_name_page_9[(MATCH_w_8_8 >> 3 & 0x1) 
32105                                       /* page at 8 */]; 
32106                                 { 
32107                                   char *name = MATCH_name;
32108                                   nextPC = 2 + MATCH_p; 
32109                                   
32110                                   #line 276 "machine/pentium/disassembler.m"
32111                                   
32112 
32113                                           sprintf (str,  name);
32114 
32115                                   
32116 
32117                                   
32118                                   
32119                                   
32120                                 }
32121                                 
32122                               } /*opt-block*/
32123                               
32124                               break;
32125                             case 5: 
32126                               if ((MATCH_w_8_8 >> 3 & 0x1) 
32127                                       /* page at 8 */ == 1) { 
32128                                 MATCH_name = 
32129                                   MATCH_name_page_12[(MATCH_w_8_8 >> 3 & 0x1) 
32130                                       /* page at 8 */]; 
32131                                 { 
32132                                   char *name = MATCH_name;
32133                                   nextPC = 2 + MATCH_p; 
32134                                   
32135                                   #line 273 "machine/pentium/disassembler.m"
32136                                   
32137 
32138                                           sprintf (str,  name);
32139 
32140                                   
32141 
32142                                   
32143                                   
32144                                   
32145                                 }
32146                                 
32147                               } /*opt-block*/
32148                               else { 
32149                                 MATCH_name = 
32150                                   MATCH_name_page_10[(MATCH_w_8_8 >> 3 & 0x1) 
32151                                       /* page at 8 */]; 
32152                                 { 
32153                                   char *name = MATCH_name;
32154                                   nextPC = 2 + MATCH_p; 
32155                                   
32156                                   #line 282 "machine/pentium/disassembler.m"
32157                                   
32158 
32159                                           sprintf (str,  name);
32160 
32161                                   
32162 
32163                                   
32164                                   
32165                                   
32166                                 }
32167                                 
32168                               } /*opt-block*/
32169                               
32170                               break;
32171                             case 6: 
32172                               if ((MATCH_w_8_8 >> 3 & 0x1) 
32173                                       /* page at 8 */ == 1) { 
32174                                 MATCH_name = 
32175                                   MATCH_name_page_13[(MATCH_w_8_8 >> 3 & 0x1) 
32176                                       /* page at 8 */]; 
32177                                 { 
32178                                   char *name = MATCH_name;
32179                                   nextPC = 2 + MATCH_p; 
32180                                   
32181                                   #line 285 "machine/pentium/disassembler.m"
32182                                   
32183 
32184                                           sprintf (str,  name);
32185 
32186                                   
32187 
32188                                   
32189                                   
32190                                   
32191                                 }
32192                                 
32193                               } /*opt-block*/
32194                               else { 
32195                                 MATCH_name = 
32196                                   MATCH_name_page_11[(MATCH_w_8_8 >> 3 & 0x1) 
32197                                       /* page at 8 */]; 
32198                                 { 
32199                                   char *name = MATCH_name;
32200                                   nextPC = 2 + MATCH_p; 
32201                                   
32202                                   #line 258 "machine/pentium/disassembler.m"
32203                                   
32204 
32205                                           sprintf (str,  name);
32206 
32207                                   
32208 
32209                                   
32210                                   
32211                                   
32212                                 }
32213                                 
32214                               } /*opt-block*/
32215                               
32216                               break;
32217                             case 7: 
32218                               if ((MATCH_w_8_8 >> 3 & 0x1) 
32219                                       /* page at 8 */ == 1) { 
32220                                 MATCH_name = 
32221                                   MATCH_name_page_14[(MATCH_w_8_8 >> 3 & 0x1) 
32222                                       /* page at 8 */]; 
32223                                 { 
32224                                   char *name = MATCH_name;
32225                                   nextPC = 2 + MATCH_p; 
32226                                   
32227                                   #line 291 "machine/pentium/disassembler.m"
32228                                   
32229 
32230                                           sprintf (str,  name);
32231 
32232                                   
32233 
32234                                   
32235                                   
32236                                   
32237                                 }
32238                                 
32239                               } /*opt-block*/
32240                               else { 
32241                                 MATCH_name = 
32242                                   MATCH_name_page_12[(MATCH_w_8_8 >> 3 & 0x1) 
32243                                       /* page at 8 */]; 
32244                                 { 
32245                                   char *name = MATCH_name;
32246                                   nextPC = 2 + MATCH_p; 
32247                                   
32248                                   #line 264 "machine/pentium/disassembler.m"
32249                                   
32250 
32251                                           sprintf (str,  name);
32252 
32253                                   
32254 
32255                                   
32256                                   
32257                                   
32258                                 }
32259                                 
32260                               } /*opt-block*/
32261                               
32262                               break;
32263                             default: assert(0);
32264                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
32265                         break;
32266                       default: assert(0);
32267                     } /* (MATCH_w_8_8 >> 4 & 0xf) -- row at 8 --*/ 
32268                   
32269                   break;
32270                 case 3: 
32271                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
32272                   
32273                     switch((MATCH_w_8_8 >> 4 & 0xf) /* row at 8 */) {
32274                       case 0: case 1: case 2: case 3: case 4: case 5: case 7: 
32275                       case 8: case 9: case 11: case 12: case 13: case 14: 
32276                       case 15: 
32277                         goto MATCH_label_a39; break;
32278                       case 6: 
32279                         if ((MATCH_w_8_8 & 0x7) /* col at 8 */ == 6) 
32280                           if ((MATCH_w_8_8 >> 3 & 0x1) /* page at 8 */ == 1) 
32281                             goto MATCH_label_a39;  /*opt-block+*/
32282                           else { 
32283                             MATCH_w_8_16 = getByte(2 + MATCH_p); 
32284                             
32285                               switch((MATCH_w_8_16 & 0x7) /* col at 16 */) {
32286                                 case 0: case 1: case 2: case 4: case 6: 
32287                                   goto MATCH_label_a39; break;
32288                                 case 3: 
32289                                   if ((MATCH_w_8_16 >> 4 & 0xf) 
32290                                           /* row at 16 */ == 10 && 
32291                                     (MATCH_w_8_16 >> 3 & 0x1) 
32292                                           /* page at 16 */ == 1) { 
32293                                     MATCH_name = 
32294                                       MATCH_name_page_15[(MATCH_w_8_16 >> 3 & 0x1) 
32295                                           /* page at 16 */]; 
32296                                     { 
32297                                       char *name = MATCH_name;
32298                                       nextPC = 3 + MATCH_p; 
32299                                       
32300                                       #line 252 "machine/pentium/disassembler.m"
32301                                       
32302 
32303                                               sprintf (str,  name);
32304 
32305                                       
32306 
32307                                       
32308                                       
32309                                       
32310                                     }
32311                                     
32312                                   } /*opt-block*/
32313                                   else 
32314                                     goto MATCH_label_a39;  /*opt-block+*/
32315                                   
32316                                   break;
32317                                 case 5: 
32318                                   if ((MATCH_w_8_16 >> 4 & 0xf) 
32319                                           /* row at 16 */ == 10) 
32320                                     if ((MATCH_w_8_16 >> 3 & 0x1) 
32321                                             /* page at 16 */ == 1) { 
32322                                       MATCH_name = "REP.LODSvow"; 
32323                                       { 
32324                                         char *name = MATCH_name;
32325                                         nextPC = 3 + MATCH_p; 
32326                                         
32327                                         #line 225 "machine/pentium/disassembler.m"
32328                                         
32329 
32330                                                 sprintf (str,  name);
32331 
32332                                         
32333 
32334                                         
32335                                         
32336                                         
32337                                       }
32338                                       
32339                                     } /*opt-block*/
32340                                     else { 
32341                                       MATCH_name = 
32342                                         MATCH_name_page_8[(MATCH_w_8_16 >> 3 & 0x1) 
32343                                             /* page at 16 */]; 
32344                                       { 
32345                                         char *name = MATCH_name;
32346                                         nextPC = 3 + MATCH_p; 
32347                                         
32348                                         #line 234 "machine/pentium/disassembler.m"
32349                                         
32350 
32351                                                 sprintf (str,  name);
32352 
32353                                         
32354 
32355                                         
32356                                         
32357                                         
32358                                       }
32359                                       
32360                                     } /*opt-block*/ /*opt-block+*/
32361                                   else 
32362                                     goto MATCH_label_a39;  /*opt-block+*/
32363                                   break;
32364                                 case 7: 
32365                                   if ((MATCH_w_8_16 >> 4 & 0xf) 
32366                                           /* row at 16 */ == 10) 
32367                                     if ((MATCH_w_8_16 >> 3 & 0x1) 
32368                                             /* page at 16 */ == 1) { 
32369                                       MATCH_name = "REP.SCASvow"; 
32370                                       { 
32371                                         char *name = MATCH_name;
32372                                         nextPC = 3 + MATCH_p; 
32373                                         
32374                                         #line 243 "machine/pentium/disassembler.m"
32375                                         
32376 
32377                                                 sprintf (str,  name);
32378 
32379                                         
32380 
32381                                         
32382                                         
32383                                         
32384                                       }
32385                                       
32386                                     } /*opt-block*/
32387                                     else { 
32388                                       MATCH_name = 
32389                                         MATCH_name_page_15[(MATCH_w_8_16 >> 3 & 0x1) 
32390                                             /* page at 16 */]; 
32391                                       { 
32392                                         char *name = MATCH_name;
32393                                         nextPC = 3 + MATCH_p; 
32394                                         
32395                                         #line 216 "machine/pentium/disassembler.m"
32396                                         
32397 
32398                                                 sprintf (str,  name);
32399 
32400                                         
32401 
32402                                         
32403                                         
32404                                         
32405                                       }
32406                                       
32407                                     } /*opt-block*/ /*opt-block+*/
32408                                   else 
32409                                     goto MATCH_label_a39;  /*opt-block+*/
32410                                   break;
32411                                 default: assert(0);
32412                               } /* (MATCH_w_8_16 & 0x7) -- col at 16 --*/ 
32413                             
32414                           } /*opt-block*/ 
32415                         else 
32416                           goto MATCH_label_a39;  /*opt-block+*/
32417                         break;
32418                       case 10: 
32419                         
32420                           switch((MATCH_w_8_8 & 0x7) /* col at 8 */) {
32421                             case 0: case 1: 
32422                               goto MATCH_label_a39; break;
32423                             case 2: 
32424                               if ((MATCH_w_8_8 >> 3 & 0x1) 
32425                                       /* page at 8 */ == 1) { 
32426                                 MATCH_name = 
32427                                   MATCH_name_page_18[(MATCH_w_8_8 >> 3 & 0x1) 
32428                                       /* page at 8 */]; 
32429                                 { 
32430                                   char *name = MATCH_name;
32431                                   nextPC = 2 + MATCH_p; 
32432                                   
32433                                   #line 249 "machine/pentium/disassembler.m"
32434                                   
32435 
32436                                           sprintf (str,  name);
32437 
32438                                   
32439 
32440                                   
32441                                   
32442                                   
32443                                 }
32444                                 
32445                               } /*opt-block*/
32446                               else 
32447                                 goto MATCH_label_a39;  /*opt-block+*/
32448                               
32449                               break;
32450                             case 3: 
32451                               if ((MATCH_w_8_8 >> 3 & 0x1) 
32452                                       /* page at 8 */ == 1) { 
32453                                 MATCH_name = 
32454                                   MATCH_name_page_19[(MATCH_w_8_8 >> 3 & 0x1) 
32455                                       /* page at 8 */]; 
32456                                 { 
32457                                   char *name = MATCH_name;
32458                                   nextPC = 2 + MATCH_p; 
32459                                   
32460                                   #line 255 "machine/pentium/disassembler.m"
32461                                   
32462 
32463                                           sprintf (str,  name);
32464 
32465                                   
32466 
32467                                   
32468                                   
32469                                   
32470                                 }
32471                                 
32472                               } /*opt-block*/
32473                               else 
32474                                 goto MATCH_label_a39;  /*opt-block+*/
32475                               
32476                               break;
32477                             case 4: 
32478                               if ((MATCH_w_8_8 >> 3 & 0x1) 
32479                                       /* page at 8 */ == 1) { 
32480                                 MATCH_name = "REP.LODSB"; 
32481                                 { 
32482                                   char *name = MATCH_name;
32483                                   nextPC = 2 + MATCH_p; 
32484                                   
32485                                   #line 222 "machine/pentium/disassembler.m"
32486                                   
32487 
32488                                           sprintf (str,  name);
32489 
32490                                   
32491 
32492                                   
32493                                   
32494                                   
32495                                 }
32496                                 
32497                               } /*opt-block*/
32498                               else { 
32499                                 MATCH_name = 
32500                                   MATCH_name_page_13[(MATCH_w_8_8 >> 3 & 0x1) 
32501                                       /* page at 8 */]; 
32502                                 { 
32503                                   char *name = MATCH_name;
32504                                   nextPC = 2 + MATCH_p; 
32505                                   
32506                                   #line 231 "machine/pentium/disassembler.m"
32507                                   
32508 
32509                                           sprintf (str,  name);
32510 
32511                                   
32512 
32513                                   
32514                                   
32515                                   
32516                                 }
32517                                 
32518                               } /*opt-block*/
32519                               
32520                               break;
32521                             case 5: 
32522                               if ((MATCH_w_8_8 >> 3 & 0x1) 
32523                                       /* page at 8 */ == 1) { 
32524                                 MATCH_name = "REP.LODSvod"; 
32525                                 { 
32526                                   char *name = MATCH_name;
32527                                   nextPC = 2 + MATCH_p; 
32528                                   
32529                                   #line 228 "machine/pentium/disassembler.m"
32530                                   
32531 
32532                                           sprintf (str,  name);
32533 
32534                                   
32535 
32536                                   
32537                                   
32538                                   
32539                                 }
32540                                 
32541                               } /*opt-block*/
32542                               else { 
32543                                 MATCH_name = 
32544                                   MATCH_name_page_14[(MATCH_w_8_8 >> 3 & 0x1) 
32545                                       /* page at 8 */]; 
32546                                 { 
32547                                   char *name = MATCH_name;
32548                                   nextPC = 2 + MATCH_p; 
32549                                   
32550                                   #line 237 "machine/pentium/disassembler.m"
32551                                   
32552 
32553                                           sprintf (str,  name);
32554 
32555                                   
32556 
32557                                   
32558                                   
32559                                   
32560                                 }
32561                                 
32562                               } /*opt-block*/
32563                               
32564                               break;
32565                             case 6: 
32566                               if ((MATCH_w_8_8 >> 3 & 0x1) 
32567                                       /* page at 8 */ == 1) { 
32568                                 MATCH_name = "REP.SCASB"; 
32569                                 { 
32570                                   char *name = MATCH_name;
32571                                   nextPC = 2 + MATCH_p; 
32572                                   
32573                                   #line 240 "machine/pentium/disassembler.m"
32574                                   
32575 
32576                                           sprintf (str,  name);
32577 
32578                                   
32579 
32580                                   
32581                                   
32582                                   
32583                                 }
32584                                 
32585                               } /*opt-block*/
32586                               else { 
32587                                 MATCH_name = 
32588                                   MATCH_name_page_18[(MATCH_w_8_8 >> 3 & 0x1) 
32589                                       /* page at 8 */]; 
32590                                 { 
32591                                   char *name = MATCH_name;
32592                                   nextPC = 2 + MATCH_p; 
32593                                   
32594                                   #line 213 "machine/pentium/disassembler.m"
32595                                   
32596 
32597                                           sprintf (str,  name);
32598 
32599                                   
32600 
32601                                   
32602                                   
32603                                   
32604                                 }
32605                                 
32606                               } /*opt-block*/
32607                               
32608                               break;
32609                             case 7: 
32610                               if ((MATCH_w_8_8 >> 3 & 0x1) 
32611                                       /* page at 8 */ == 1) { 
32612                                 MATCH_name = "REP.SCASvod"; 
32613                                 { 
32614                                   char *name = MATCH_name;
32615                                   nextPC = 2 + MATCH_p; 
32616                                   
32617                                   #line 246 "machine/pentium/disassembler.m"
32618                                   
32619 
32620                                           sprintf (str,  name);
32621 
32622                                   
32623 
32624                                   
32625                                   
32626                                   
32627                                 }
32628                                 
32629                               } /*opt-block*/
32630                               else { 
32631                                 MATCH_name = 
32632                                   MATCH_name_page_19[(MATCH_w_8_8 >> 3 & 0x1) 
32633                                       /* page at 8 */]; 
32634                                 { 
32635                                   char *name = MATCH_name;
32636                                   nextPC = 2 + MATCH_p; 
32637                                   
32638                                   #line 219 "machine/pentium/disassembler.m"
32639                                   
32640 
32641                                           sprintf (str,  name);
32642 
32643                                   
32644 
32645                                   
32646                                   
32647                                   
32648                                 }
32649                                 
32650                               } /*opt-block*/
32651                               
32652                               break;
32653                             default: assert(0);
32654                           } /* (MATCH_w_8_8 & 0x7) -- col at 8 --*/ 
32655                         break;
32656                       default: assert(0);
32657                     } /* (MATCH_w_8_8 >> 4 & 0xf) -- row at 8 --*/ 
32658                   
32659                   break;
32660                 case 5: 
32661                   nextPC = 1 + MATCH_p; 
32662                   
32663                   #line 959 "machine/pentium/disassembler.m"
32664                   
32665 
32666                           sprintf (str,  "CMC");
32667 
32668                   
32669 
32670                   
32671                   
32672                   
32673                   
32674                   break;
32675                 case 6: 
32676                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
32677                   
32678                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
32679                       case 0: 
32680                         
32681                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
32682                             case 0: 
32683                               
32684                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
32685                                   case 0: case 1: case 2: case 3: case 6: 
32686                                   case 7: 
32687                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
32688                                     goto MATCH_label_a1138; 
32689                                     
32690                                     break;
32691                                   case 4: 
32692                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
32693                                     if ((MATCH_w_8_16 & 0x7) 
32694                                             /* base at 16 */ == 5 && 
32695                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32696                                             /* index at 16 */ && 
32697                                       (MATCH_w_8_16 >> 3 & 0x7) 
32698                                             /* index at 16 */ < 8)) { 
32699                                       MATCH_w_8_56 = getByte(7 + MATCH_p); 
32700                                       goto MATCH_label_a1140; 
32701                                       
32702                                     } /*opt-block*/
32703                                     else { 
32704                                       MATCH_w_8_24 = getByte(3 + MATCH_p); 
32705                                       goto MATCH_label_a1139; 
32706                                       
32707                                     } /*opt-block*/
32708                                     
32709                                     break;
32710                                   case 5: 
32711                                     MATCH_w_8_48 = getByte(6 + MATCH_p); 
32712                                     goto MATCH_label_a1141; 
32713                                     
32714                                     break;
32715                                   default: assert(0);
32716                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
32717                               break;
32718                             case 1: 
32719                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32720                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32721                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32722                                       /* index at 16 */ && 
32723                                 (MATCH_w_8_16 >> 3 & 0x7) 
32724                                       /* index at 16 */ < 8)) { 
32725                                 MATCH_w_8_32 = getByte(4 + MATCH_p); 
32726                                 { 
32727                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
32728                                   unsigned i8 = 
32729                                     (MATCH_w_8_32 & 0xff) /* i8 at 32 */;
32730                                   nextPC = 5 + MATCH_p; 
32731                                   
32732                                   #line 110 "machine/pentium/disassembler.m"
32733                                   
32734 
32735                                           sprintf (str,  "TEST.Eb.Ib", DIS_EADDR8, DIS_I8);
32736 
32737                                   
32738 
32739                                   
32740                                   
32741                                   
32742                                 }
32743                                 
32744                               } /*opt-block*/
32745                               else { 
32746                                 MATCH_w_8_24 = getByte(3 + MATCH_p); 
32747                                 goto MATCH_label_a1139; 
32748                                 
32749                               } /*opt-block*/
32750                               
32751                               break;
32752                             case 2: 
32753                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32754                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32755                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32756                                       /* index at 16 */ && 
32757                                 (MATCH_w_8_16 >> 3 & 0x7) 
32758                                       /* index at 16 */ < 8)) { 
32759                                 MATCH_w_8_56 = getByte(7 + MATCH_p); 
32760                                 goto MATCH_label_a1140; 
32761                                 
32762                               } /*opt-block*/
32763                               else { 
32764                                 MATCH_w_8_48 = getByte(6 + MATCH_p); 
32765                                 goto MATCH_label_a1141; 
32766                                 
32767                               } /*opt-block*/
32768                               
32769                               break;
32770                             case 3: 
32771                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32772                               goto MATCH_label_a1138; 
32773                               
32774                               break;
32775                             default: assert(0);
32776                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
32777                         break;
32778                       case 1: 
32779                         goto MATCH_label_a39; break;
32780                       case 2: 
32781                         
32782                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
32783                             case 0: 
32784                               
32785                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
32786                                   case 0: case 1: case 2: case 3: case 6: 
32787                                   case 7: 
32788                                     goto MATCH_label_a1142; break;
32789                                   case 4: 
32790                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
32791                                     if ((MATCH_w_8_16 & 0x7) 
32792                                             /* base at 16 */ == 5 && 
32793                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32794                                             /* index at 16 */ && 
32795                                       (MATCH_w_8_16 >> 3 & 0x7) 
32796                                             /* index at 16 */ < 8)) 
32797                                       goto MATCH_label_a1144;  /*opt-block+*/
32798                                     else 
32799                                       goto MATCH_label_a1143;  /*opt-block+*/
32800                                     
32801                                     break;
32802                                   case 5: 
32803                                     goto MATCH_label_a1145; break;
32804                                   default: assert(0);
32805                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
32806                               break;
32807                             case 1: 
32808                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32809                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32810                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32811                                       /* index at 16 */ && 
32812                                 (MATCH_w_8_16 >> 3 & 0x7) 
32813                                       /* index at 16 */ < 8)) { 
32814                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
32815                                 nextPC = 4 + MATCH_p; 
32816                                 
32817                                 #line 621 "machine/pentium/disassembler.m"
32818                                 
32819 
32820                                         sprintf (str,  "NOTb", DIS_EADDR8);
32821 
32822                                 
32823 
32824                                 
32825                                 
32826                                 
32827                               } /*opt-block*//*opt-block+*/
32828                               else 
32829                                 goto MATCH_label_a1143;  /*opt-block+*/
32830                               
32831                               break;
32832                             case 2: 
32833                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32834                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32835                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32836                                       /* index at 16 */ && 
32837                                 (MATCH_w_8_16 >> 3 & 0x7) 
32838                                       /* index at 16 */ < 8)) 
32839                                 goto MATCH_label_a1144;  /*opt-block+*/
32840                               else 
32841                                 goto MATCH_label_a1145;  /*opt-block+*/
32842                               
32843                               break;
32844                             case 3: 
32845                               goto MATCH_label_a1142; break;
32846                             default: assert(0);
32847                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
32848                         break;
32849                       case 3: 
32850                         
32851                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
32852                             case 0: 
32853                               
32854                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
32855                                   case 0: case 1: case 2: case 3: case 6: 
32856                                   case 7: 
32857                                     goto MATCH_label_a1146; break;
32858                                   case 4: 
32859                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
32860                                     if ((MATCH_w_8_16 & 0x7) 
32861                                             /* base at 16 */ == 5 && 
32862                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32863                                             /* index at 16 */ && 
32864                                       (MATCH_w_8_16 >> 3 & 0x7) 
32865                                             /* index at 16 */ < 8)) 
32866                                       goto MATCH_label_a1148;  /*opt-block+*/
32867                                     else 
32868                                       goto MATCH_label_a1147;  /*opt-block+*/
32869                                     
32870                                     break;
32871                                   case 5: 
32872                                     goto MATCH_label_a1149; break;
32873                                   default: assert(0);
32874                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
32875                               break;
32876                             case 1: 
32877                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32878                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32879                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32880                                       /* index at 16 */ && 
32881                                 (MATCH_w_8_16 >> 3 & 0x7) 
32882                                       /* index at 16 */ < 8)) { 
32883                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
32884                                 nextPC = 4 + MATCH_p; 
32885                                 
32886                                 #line 630 "machine/pentium/disassembler.m"
32887                                 
32888 
32889                                         sprintf (str,  "NEGb", DIS_EADDR8);
32890 
32891                                 
32892 
32893                                 
32894                                 
32895                                 
32896                               } /*opt-block*//*opt-block+*/
32897                               else 
32898                                 goto MATCH_label_a1147;  /*opt-block+*/
32899                               
32900                               break;
32901                             case 2: 
32902                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32903                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32904                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32905                                       /* index at 16 */ && 
32906                                 (MATCH_w_8_16 >> 3 & 0x7) 
32907                                       /* index at 16 */ < 8)) 
32908                                 goto MATCH_label_a1148;  /*opt-block+*/
32909                               else 
32910                                 goto MATCH_label_a1149;  /*opt-block+*/
32911                               
32912                               break;
32913                             case 3: 
32914                               goto MATCH_label_a1146; break;
32915                             default: assert(0);
32916                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
32917                         break;
32918                       case 4: 
32919                         
32920                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
32921                             case 0: 
32922                               
32923                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
32924                                   case 0: case 1: case 2: case 3: case 6: 
32925                                   case 7: 
32926                                     goto MATCH_label_a1150; break;
32927                                   case 4: 
32928                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
32929                                     if ((MATCH_w_8_16 & 0x7) 
32930                                             /* base at 16 */ == 5 && 
32931                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32932                                             /* index at 16 */ && 
32933                                       (MATCH_w_8_16 >> 3 & 0x7) 
32934                                             /* index at 16 */ < 8)) 
32935                                       goto MATCH_label_a1152;  /*opt-block+*/
32936                                     else 
32937                                       goto MATCH_label_a1151;  /*opt-block+*/
32938                                     
32939                                     break;
32940                                   case 5: 
32941                                     goto MATCH_label_a1153; break;
32942                                   default: assert(0);
32943                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
32944                               break;
32945                             case 1: 
32946                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32947                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32948                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32949                                       /* index at 16 */ && 
32950                                 (MATCH_w_8_16 >> 3 & 0x7) 
32951                                       /* index at 16 */ < 8)) { 
32952                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
32953                                 nextPC = 4 + MATCH_p; 
32954                                 
32955                                 #line 639 "machine/pentium/disassembler.m"
32956                                 
32957 
32958                                         sprintf (str,  "MUL.AL", DIS_EADDR8);
32959 
32960                                 
32961 
32962                                 
32963                                 
32964                                 
32965                               } /*opt-block*//*opt-block+*/
32966                               else 
32967                                 goto MATCH_label_a1151;  /*opt-block+*/
32968                               
32969                               break;
32970                             case 2: 
32971                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
32972                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
32973                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
32974                                       /* index at 16 */ && 
32975                                 (MATCH_w_8_16 >> 3 & 0x7) 
32976                                       /* index at 16 */ < 8)) 
32977                                 goto MATCH_label_a1152;  /*opt-block+*/
32978                               else 
32979                                 goto MATCH_label_a1153;  /*opt-block+*/
32980                               
32981                               break;
32982                             case 3: 
32983                               goto MATCH_label_a1150; break;
32984                             default: assert(0);
32985                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
32986                         break;
32987                       case 5: 
32988                         
32989                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
32990                             case 0: 
32991                               
32992                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
32993                                   case 0: case 1: case 2: case 3: case 6: 
32994                                   case 7: 
32995                                     goto MATCH_label_a1154; break;
32996                                   case 4: 
32997                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
32998                                     if ((MATCH_w_8_16 & 0x7) 
32999                                             /* base at 16 */ == 5 && 
33000                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33001                                             /* index at 16 */ && 
33002                                       (MATCH_w_8_16 >> 3 & 0x7) 
33003                                             /* index at 16 */ < 8)) 
33004                                       goto MATCH_label_a1156;  /*opt-block+*/
33005                                     else 
33006                                       goto MATCH_label_a1155;  /*opt-block+*/
33007                                     
33008                                     break;
33009                                   case 5: 
33010                                     goto MATCH_label_a1157; break;
33011                                   default: assert(0);
33012                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33013                               break;
33014                             case 1: 
33015                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33016                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33017                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33018                                       /* index at 16 */ && 
33019                                 (MATCH_w_8_16 >> 3 & 0x7) 
33020                                       /* index at 16 */ < 8)) { 
33021                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33022                                 nextPC = 4 + MATCH_p; 
33023                                 
33024                                 #line 881 "machine/pentium/disassembler.m"
33025                                 
33026 
33027                                         sprintf (str,  "IMULb", DIS_EADDR8);
33028 
33029                                 
33030 
33031                                 
33032                                 
33033                                 
33034                               } /*opt-block*//*opt-block+*/
33035                               else 
33036                                 goto MATCH_label_a1155;  /*opt-block+*/
33037                               
33038                               break;
33039                             case 2: 
33040                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33041                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33042                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33043                                       /* index at 16 */ && 
33044                                 (MATCH_w_8_16 >> 3 & 0x7) 
33045                                       /* index at 16 */ < 8)) 
33046                                 goto MATCH_label_a1156;  /*opt-block+*/
33047                               else 
33048                                 goto MATCH_label_a1157;  /*opt-block+*/
33049                               
33050                               break;
33051                             case 3: 
33052                               goto MATCH_label_a1154; break;
33053                             default: assert(0);
33054                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33055                         break;
33056                       case 6: 
33057                         
33058                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33059                             case 0: 
33060                               
33061                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33062                                   case 0: case 1: case 2: case 3: case 6: 
33063                                   case 7: 
33064                                     goto MATCH_label_a1158; break;
33065                                   case 4: 
33066                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33067                                     if ((MATCH_w_8_16 & 0x7) 
33068                                             /* base at 16 */ == 5 && 
33069                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33070                                             /* index at 16 */ && 
33071                                       (MATCH_w_8_16 >> 3 & 0x7) 
33072                                             /* index at 16 */ < 8)) 
33073                                       goto MATCH_label_a1160;  /*opt-block+*/
33074                                     else 
33075                                       goto MATCH_label_a1159;  /*opt-block+*/
33076                                     
33077                                     break;
33078                                   case 5: 
33079                                     goto MATCH_label_a1161; break;
33080                                   default: assert(0);
33081                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33082                               break;
33083                             case 1: 
33084                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33085                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33086                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33087                                       /* index at 16 */ && 
33088                                 (MATCH_w_8_16 >> 3 & 0x7) 
33089                                       /* index at 16 */ < 8)) { 
33090                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33091                                 nextPC = 4 + MATCH_p; 
33092                                 
33093                                 #line 905 "machine/pentium/disassembler.m"
33094                                 
33095 
33096                                         sprintf (str,  "DIVAL", DIS_EADDR8);
33097 
33098                                 
33099 
33100                                 
33101                                 
33102                                 
33103                               } /*opt-block*//*opt-block+*/
33104                               else 
33105                                 goto MATCH_label_a1159;  /*opt-block+*/
33106                               
33107                               break;
33108                             case 2: 
33109                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33110                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33111                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33112                                       /* index at 16 */ && 
33113                                 (MATCH_w_8_16 >> 3 & 0x7) 
33114                                       /* index at 16 */ < 8)) 
33115                                 goto MATCH_label_a1160;  /*opt-block+*/
33116                               else 
33117                                 goto MATCH_label_a1161;  /*opt-block+*/
33118                               
33119                               break;
33120                             case 3: 
33121                               goto MATCH_label_a1158; break;
33122                             default: assert(0);
33123                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33124                         break;
33125                       case 7: 
33126                         
33127                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33128                             case 0: 
33129                               
33130                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33131                                   case 0: case 1: case 2: case 3: case 6: 
33132                                   case 7: 
33133                                     goto MATCH_label_a1162; break;
33134                                   case 4: 
33135                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33136                                     if ((MATCH_w_8_16 & 0x7) 
33137                                             /* base at 16 */ == 5 && 
33138                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33139                                             /* index at 16 */ && 
33140                                       (MATCH_w_8_16 >> 3 & 0x7) 
33141                                             /* index at 16 */ < 8)) 
33142                                       goto MATCH_label_a1164;  /*opt-block+*/
33143                                     else 
33144                                       goto MATCH_label_a1163;  /*opt-block+*/
33145                                     
33146                                     break;
33147                                   case 5: 
33148                                     goto MATCH_label_a1165; break;
33149                                   default: assert(0);
33150                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33151                               break;
33152                             case 1: 
33153                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33154                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33155                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33156                                       /* index at 16 */ && 
33157                                 (MATCH_w_8_16 >> 3 & 0x7) 
33158                                       /* index at 16 */ < 8)) { 
33159                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33160                                 nextPC = 4 + MATCH_p; 
33161                                 
33162                                 #line 890 "machine/pentium/disassembler.m"
33163                                 
33164 
33165                                         sprintf (str,  "IDIV", DIS_EADDR8); /* ?? */
33166 
33167                                 
33168 
33169                                 //  | HLT() =>
33170 
33171                                 //      sprintf (str,  "HLT");
33172 
33173                                 
33174 
33175                                 
33176                                 
33177                                 
33178                               } /*opt-block*//*opt-block+*/
33179                               else 
33180                                 goto MATCH_label_a1163;  /*opt-block+*/
33181                               
33182                               break;
33183                             case 2: 
33184                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33185                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33186                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33187                                       /* index at 16 */ && 
33188                                 (MATCH_w_8_16 >> 3 & 0x7) 
33189                                       /* index at 16 */ < 8)) 
33190                                 goto MATCH_label_a1164;  /*opt-block+*/
33191                               else 
33192                                 goto MATCH_label_a1165;  /*opt-block+*/
33193                               
33194                               break;
33195                             case 3: 
33196                               goto MATCH_label_a1162; break;
33197                             default: assert(0);
33198                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33199                         break;
33200                       default: assert(0);
33201                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
33202                   
33203                   break;
33204                 case 7: 
33205                   MATCH_w_8_8 = getByte(1 + MATCH_p); 
33206                   
33207                     switch((MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */) {
33208                       case 0: 
33209                         
33210                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33211                             case 0: 
33212                               
33213                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33214                                   case 0: case 1: case 2: case 3: case 6: 
33215                                   case 7: 
33216                                     MATCH_w_32_16 = getDword(2 + MATCH_p); 
33217                                     goto MATCH_label_a1166; 
33218                                     
33219                                     break;
33220                                   case 4: 
33221                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33222                                     if ((MATCH_w_8_16 & 0x7) 
33223                                             /* base at 16 */ == 5 && 
33224                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33225                                             /* index at 16 */ && 
33226                                       (MATCH_w_8_16 >> 3 & 0x7) 
33227                                             /* index at 16 */ < 8)) { 
33228                                       MATCH_w_32_56 = getDword(7 + MATCH_p); 
33229                                       goto MATCH_label_a1168; 
33230                                       
33231                                     } /*opt-block*/
33232                                     else { 
33233                                       MATCH_w_32_24 = getDword(3 + MATCH_p); 
33234                                       goto MATCH_label_a1167; 
33235                                       
33236                                     } /*opt-block*/
33237                                     
33238                                     break;
33239                                   case 5: 
33240                                     MATCH_w_32_48 = getDword(6 + MATCH_p); 
33241                                     goto MATCH_label_a1169; 
33242                                     
33243                                     break;
33244                                   default: assert(0);
33245                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33246                               break;
33247                             case 1: 
33248                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33249                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33250                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33251                                       /* index at 16 */ && 
33252                                 (MATCH_w_8_16 >> 3 & 0x7) 
33253                                       /* index at 16 */ < 8)) { 
33254                                 MATCH_w_32_32 = getDword(4 + MATCH_p); 
33255                                 { 
33256                                   unsigned Eaddr = 1 + addressToPC(MATCH_p);
33257                                   unsigned i32 = 
33258                                     MATCH_w_32_32 /* i32 at 32 */;
33259                                   nextPC = 8 + MATCH_p; 
33260                                   
33261                                   #line 104 "machine/pentium/disassembler.m"
33262                                   
33263 
33264                                           sprintf (str,  "TEST.Ed.Id", DIS_EADDR32, DIS_I32);
33265 
33266                                   
33267 
33268                                   
33269                                   
33270                                   
33271                                 }
33272                                 
33273                               } /*opt-block*/
33274                               else { 
33275                                 MATCH_w_32_24 = getDword(3 + MATCH_p); 
33276                                 goto MATCH_label_a1167; 
33277                                 
33278                               } /*opt-block*/
33279                               
33280                               break;
33281                             case 2: 
33282                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33283                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33284                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33285                                       /* index at 16 */ && 
33286                                 (MATCH_w_8_16 >> 3 & 0x7) 
33287                                       /* index at 16 */ < 8)) { 
33288                                 MATCH_w_32_56 = getDword(7 + MATCH_p); 
33289                                 goto MATCH_label_a1168; 
33290                                 
33291                               } /*opt-block*/
33292                               else { 
33293                                 MATCH_w_32_48 = getDword(6 + MATCH_p); 
33294                                 goto MATCH_label_a1169; 
33295                                 
33296                               } /*opt-block*/
33297                               
33298                               break;
33299                             case 3: 
33300                               MATCH_w_32_16 = getDword(2 + MATCH_p); 
33301                               goto MATCH_label_a1166; 
33302                               
33303                               break;
33304                             default: assert(0);
33305                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33306                         break;
33307                       case 1: 
33308                         goto MATCH_label_a39; break;
33309                       case 2: 
33310                         
33311                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33312                             case 0: 
33313                               
33314                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33315                                   case 0: case 1: case 2: case 3: case 6: 
33316                                   case 7: 
33317                                     goto MATCH_label_a1170; break;
33318                                   case 4: 
33319                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33320                                     if ((MATCH_w_8_16 & 0x7) 
33321                                             /* base at 16 */ == 5 && 
33322                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33323                                             /* index at 16 */ && 
33324                                       (MATCH_w_8_16 >> 3 & 0x7) 
33325                                             /* index at 16 */ < 8)) 
33326                                       goto MATCH_label_a1172;  /*opt-block+*/
33327                                     else 
33328                                       goto MATCH_label_a1171;  /*opt-block+*/
33329                                     
33330                                     break;
33331                                   case 5: 
33332                                     goto MATCH_label_a1173; break;
33333                                   default: assert(0);
33334                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33335                               break;
33336                             case 1: 
33337                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33338                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33339                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33340                                       /* index at 16 */ && 
33341                                 (MATCH_w_8_16 >> 3 & 0x7) 
33342                                       /* index at 16 */ < 8)) { 
33343                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33344                                 nextPC = 4 + MATCH_p; 
33345                                 
33346                                 #line 615 "machine/pentium/disassembler.m"
33347                                 
33348 
33349                                         sprintf (str,  "NOTod", DIS_EADDR32);
33350 
33351                                 
33352 
33353                                 
33354                                 
33355                                 
33356                               } /*opt-block*//*opt-block+*/
33357                               else 
33358                                 goto MATCH_label_a1171;  /*opt-block+*/
33359                               
33360                               break;
33361                             case 2: 
33362                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33363                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33364                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33365                                       /* index at 16 */ && 
33366                                 (MATCH_w_8_16 >> 3 & 0x7) 
33367                                       /* index at 16 */ < 8)) 
33368                                 goto MATCH_label_a1172;  /*opt-block+*/
33369                               else 
33370                                 goto MATCH_label_a1173;  /*opt-block+*/
33371                               
33372                               break;
33373                             case 3: 
33374                               goto MATCH_label_a1170; break;
33375                             default: assert(0);
33376                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33377                         break;
33378                       case 3: 
33379                         
33380                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33381                             case 0: 
33382                               
33383                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33384                                   case 0: case 1: case 2: case 3: case 6: 
33385                                   case 7: 
33386                                     goto MATCH_label_a1174; break;
33387                                   case 4: 
33388                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33389                                     if ((MATCH_w_8_16 & 0x7) 
33390                                             /* base at 16 */ == 5 && 
33391                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33392                                             /* index at 16 */ && 
33393                                       (MATCH_w_8_16 >> 3 & 0x7) 
33394                                             /* index at 16 */ < 8)) 
33395                                       goto MATCH_label_a1176;  /*opt-block+*/
33396                                     else 
33397                                       goto MATCH_label_a1175;  /*opt-block+*/
33398                                     
33399                                     break;
33400                                   case 5: 
33401                                     goto MATCH_label_a1177; break;
33402                                   default: assert(0);
33403                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33404                               break;
33405                             case 1: 
33406                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33407                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33408                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33409                                       /* index at 16 */ && 
33410                                 (MATCH_w_8_16 >> 3 & 0x7) 
33411                                       /* index at 16 */ < 8)) { 
33412                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33413                                 nextPC = 4 + MATCH_p; 
33414                                 
33415                                 #line 624 "machine/pentium/disassembler.m"
33416                                 
33417 
33418                                         sprintf (str,  "NEGod", DIS_EADDR32);
33419 
33420                                 
33421 
33422                                 
33423                                 
33424                                 
33425                               } /*opt-block*//*opt-block+*/
33426                               else 
33427                                 goto MATCH_label_a1175;  /*opt-block+*/
33428                               
33429                               break;
33430                             case 2: 
33431                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33432                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33433                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33434                                       /* index at 16 */ && 
33435                                 (MATCH_w_8_16 >> 3 & 0x7) 
33436                                       /* index at 16 */ < 8)) 
33437                                 goto MATCH_label_a1176;  /*opt-block+*/
33438                               else 
33439                                 goto MATCH_label_a1177;  /*opt-block+*/
33440                               
33441                               break;
33442                             case 3: 
33443                               goto MATCH_label_a1174; break;
33444                             default: assert(0);
33445                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33446                         break;
33447                       case 4: 
33448                         
33449                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33450                             case 0: 
33451                               
33452                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33453                                   case 0: case 1: case 2: case 3: case 6: 
33454                                   case 7: 
33455                                     goto MATCH_label_a1178; break;
33456                                   case 4: 
33457                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33458                                     if ((MATCH_w_8_16 & 0x7) 
33459                                             /* base at 16 */ == 5 && 
33460                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33461                                             /* index at 16 */ && 
33462                                       (MATCH_w_8_16 >> 3 & 0x7) 
33463                                             /* index at 16 */ < 8)) 
33464                                       goto MATCH_label_a1180;  /*opt-block+*/
33465                                     else 
33466                                       goto MATCH_label_a1179;  /*opt-block+*/
33467                                     
33468                                     break;
33469                                   case 5: 
33470                                     goto MATCH_label_a1181; break;
33471                                   default: assert(0);
33472                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33473                               break;
33474                             case 1: 
33475                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33476                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33477                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33478                                       /* index at 16 */ && 
33479                                 (MATCH_w_8_16 >> 3 & 0x7) 
33480                                       /* index at 16 */ < 8)) { 
33481                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33482                                 nextPC = 4 + MATCH_p; 
33483                                 
33484                                 #line 633 "machine/pentium/disassembler.m"
33485                                 
33486 
33487                                         sprintf (str,  "MUL.AXod", DIS_EADDR32);
33488 
33489                                 
33490 
33491                                 
33492                                 
33493                                 
33494                               } /*opt-block*//*opt-block+*/
33495                               else 
33496                                 goto MATCH_label_a1179;  /*opt-block+*/
33497                               
33498                               break;
33499                             case 2: 
33500                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33501                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33502                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33503                                       /* index at 16 */ && 
33504                                 (MATCH_w_8_16 >> 3 & 0x7) 
33505                                       /* index at 16 */ < 8)) 
33506                                 goto MATCH_label_a1180;  /*opt-block+*/
33507                               else 
33508                                 goto MATCH_label_a1181;  /*opt-block+*/
33509                               
33510                               break;
33511                             case 3: 
33512                               goto MATCH_label_a1178; break;
33513                             default: assert(0);
33514                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33515                         break;
33516                       case 5: 
33517                         
33518                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33519                             case 0: 
33520                               
33521                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33522                                   case 0: case 1: case 2: case 3: case 6: 
33523                                   case 7: 
33524                                     goto MATCH_label_a1182; break;
33525                                   case 4: 
33526                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33527                                     if ((MATCH_w_8_16 & 0x7) 
33528                                             /* base at 16 */ == 5 && 
33529                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33530                                             /* index at 16 */ && 
33531                                       (MATCH_w_8_16 >> 3 & 0x7) 
33532                                             /* index at 16 */ < 8)) 
33533                                       goto MATCH_label_a1184;  /*opt-block+*/
33534                                     else 
33535                                       goto MATCH_label_a1183;  /*opt-block+*/
33536                                     
33537                                     break;
33538                                   case 5: 
33539                                     goto MATCH_label_a1185; break;
33540                                   default: assert(0);
33541                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33542                               break;
33543                             case 1: 
33544                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33545                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33546                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33547                                       /* index at 16 */ && 
33548                                 (MATCH_w_8_16 >> 3 & 0x7) 
33549                                       /* index at 16 */ < 8)) { 
33550                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33551                                 nextPC = 4 + MATCH_p; 
33552                                 
33553                                 #line 875 "machine/pentium/disassembler.m"
33554                                 
33555 
33556                                         sprintf (str,  "IMULod", DIS_EADDR32);
33557 
33558                                 
33559 
33560                                 
33561                                 
33562                                 
33563                               } /*opt-block*//*opt-block+*/
33564                               else 
33565                                 goto MATCH_label_a1183;  /*opt-block+*/
33566                               
33567                               break;
33568                             case 2: 
33569                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33570                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33571                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33572                                       /* index at 16 */ && 
33573                                 (MATCH_w_8_16 >> 3 & 0x7) 
33574                                       /* index at 16 */ < 8)) 
33575                                 goto MATCH_label_a1184;  /*opt-block+*/
33576                               else 
33577                                 goto MATCH_label_a1185;  /*opt-block+*/
33578                               
33579                               break;
33580                             case 3: 
33581                               goto MATCH_label_a1182; break;
33582                             default: assert(0);
33583                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33584                         break;
33585                       case 6: 
33586                         
33587                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33588                             case 0: 
33589                               
33590                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33591                                   case 0: case 1: case 2: case 3: case 6: 
33592                                   case 7: 
33593                                     goto MATCH_label_a1186; break;
33594                                   case 4: 
33595                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33596                                     if ((MATCH_w_8_16 & 0x7) 
33597                                             /* base at 16 */ == 5 && 
33598                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33599                                             /* index at 16 */ && 
33600                                       (MATCH_w_8_16 >> 3 & 0x7) 
33601                                             /* index at 16 */ < 8)) 
33602                                       goto MATCH_label_a1188;  /*opt-block+*/
33603                                     else 
33604                                       goto MATCH_label_a1187;  /*opt-block+*/
33605                                     
33606                                     break;
33607                                   case 5: 
33608                                     goto MATCH_label_a1189; break;
33609                                   default: assert(0);
33610                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33611                               break;
33612                             case 1: 
33613                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33614                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33615                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33616                                       /* index at 16 */ && 
33617                                 (MATCH_w_8_16 >> 3 & 0x7) 
33618                                       /* index at 16 */ < 8)) { 
33619                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33620                                 nextPC = 4 + MATCH_p; 
33621                                 
33622                                 #line 899 "machine/pentium/disassembler.m"
33623                                 
33624 
33625                                         sprintf (str,  "DIVeAX", DIS_EADDR32);
33626 
33627                                 
33628 
33629                                 
33630                                 
33631                                 
33632                               } /*opt-block*//*opt-block+*/
33633                               else 
33634                                 goto MATCH_label_a1187;  /*opt-block+*/
33635                               
33636                               break;
33637                             case 2: 
33638                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33639                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33640                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33641                                       /* index at 16 */ && 
33642                                 (MATCH_w_8_16 >> 3 & 0x7) 
33643                                       /* index at 16 */ < 8)) 
33644                                 goto MATCH_label_a1188;  /*opt-block+*/
33645                               else 
33646                                 goto MATCH_label_a1189;  /*opt-block+*/
33647                               
33648                               break;
33649                             case 3: 
33650                               goto MATCH_label_a1186; break;
33651                             default: assert(0);
33652                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33653                         break;
33654                       case 7: 
33655                         
33656                           switch((MATCH_w_8_8 >> 6 & 0x3) /* mod at 8 */) {
33657                             case 0: 
33658                               
33659                                 switch((MATCH_w_8_8 & 0x7) /* r_m at 8 */) {
33660                                   case 0: case 1: case 2: case 3: case 6: 
33661                                   case 7: 
33662                                     goto MATCH_label_a1190; break;
33663                                   case 4: 
33664                                     MATCH_w_8_16 = getByte(2 + MATCH_p); 
33665                                     if ((MATCH_w_8_16 & 0x7) 
33666                                             /* base at 16 */ == 5 && 
33667                                       (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33668                                             /* index at 16 */ && 
33669                                       (MATCH_w_8_16 >> 3 & 0x7) 
33670                                             /* index at 16 */ < 8)) 
33671                                       goto MATCH_label_a1192;  /*opt-block+*/
33672                                     else 
33673                                       goto MATCH_label_a1191;  /*opt-block+*/
33674                                     
33675                                     break;
33676                                   case 5: 
33677                                     goto MATCH_label_a1193; break;
33678                                   default: assert(0);
33679                                 } /* (MATCH_w_8_8 & 0x7) -- r_m at 8 --*/ 
33680                               break;
33681                             case 1: 
33682                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33683                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33684                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33685                                       /* index at 16 */ && 
33686                                 (MATCH_w_8_16 >> 3 & 0x7) 
33687                                       /* index at 16 */ < 8)) { 
33688                                 unsigned Eaddr = 1 + addressToPC(MATCH_p);
33689                                 nextPC = 4 + MATCH_p; 
33690                                 
33691                                 #line 884 "machine/pentium/disassembler.m"
33692                                 
33693 
33694                                         sprintf (str,  "IDIVeAX", DIS_EADDR32);
33695 
33696                                 
33697 
33698                                 
33699                                 
33700                                 
33701                               } /*opt-block*//*opt-block+*/
33702                               else 
33703                                 goto MATCH_label_a1191;  /*opt-block+*/
33704                               
33705                               break;
33706                             case 2: 
33707                               MATCH_w_8_16 = getByte(2 + MATCH_p); 
33708                               if ((MATCH_w_8_8 & 0x7) /* r_m at 8 */ == 4 && 
33709                                 (0 <= (MATCH_w_8_16 >> 3 & 0x7) 
33710                                       /* index at 16 */ && 
33711                                 (MATCH_w_8_16 >> 3 & 0x7) 
33712                                       /* index at 16 */ < 8)) 
33713                                 goto MATCH_label_a1192;  /*opt-block+*/
33714                               else 
33715                                 goto MATCH_label_a1193;  /*opt-block+*/
33716                               
33717                               break;
33718                             case 3: 
33719                               goto MATCH_label_a1190; break;
33720                             default: assert(0);
33721                           } /* (MATCH_w_8_8 >> 6 & 0x3) -- mod at 8 --*/ 
33722                         break;
33723                       default: assert(0);
33724                     } /* (MATCH_w_8_8 >> 3 & 0x7) -- reg_opcode at 8 --*/ 
33725                   
33726                   break;
33727                 default: assert(0);
33728               } /* (MATCH_w_8_0 & 0x7) -- col at 0 --*/  
33729           break;
33730         default: assert(0);
33731       } /* (MATCH_w_8_0 >> 4 & 0xf) -- row at 0 --*/ 
33732     
33733   }goto MATCH_finished_a; 
33734   
33735   MATCH_label_a0: (void)0; /*placeholder for label*/ 
33736     { 
33737       unsigned Eaddr = 1 + addressToPC(MATCH_p);
33738       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
33739       nextPC = 2 + MATCH_p; 
33740       
33741       #line 1219 "machine/pentium/disassembler.m"
33742       
33743 
33744               sprintf (str,  "ADDmrb", DIS_EADDR8, DIS_R8);
33745 
33746       
33747 
33748       
33749       
33750       
33751     } 
33752     goto MATCH_finished_a; 
33753     
33754   MATCH_label_a1: (void)0; /*placeholder for label*/ 
33755     { 
33756       unsigned Eaddr = 1 + addressToPC(MATCH_p);
33757       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
33758       nextPC = 3 + MATCH_p; 
33759       
33760       #line 1219 "machine/pentium/disassembler.m"
33761       
33762 
33763               sprintf (str,  "ADDmrb", DIS_EADDR8, DIS_R8);
33764 
33765       
33766 
33767       
33768       
33769       
33770     } 
33771     goto MATCH_finished_a; 
33772     
33773   MATCH_label_a2: (void)0; /*placeholder for label*/ 
33774     { 
33775       unsigned Eaddr = 1 + addressToPC(MATCH_p);
33776       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
33777       nextPC = 7 + MATCH_p; 
33778       
33779       #line 1219 "machine/pentium/disassembler.m"
33780       
33781 
33782               sprintf (str,  "ADDmrb", DIS_EADDR8, DIS_R8);
33783 
33784       
33785 
33786       
33787       
33788       
33789     } 
33790     goto MATCH_finished_a; 
33791     
33792   MATCH_label_a3: (void)0; /*placeholder for label*/ 
33793     { 
33794       unsigned Eaddr = 1 + addressToPC(MATCH_p);
33795       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
33796       nextPC = 6 + MATCH_p; 
33797       
33798       #line 1219 "machine/pentium/disassembler.m"
33799       
33800 
33801               sprintf (str,  "ADDmrb", DIS_EADDR8, DIS_R8);
33802 
33803       
33804 
33805       
33806       
33807       
33808     } 
33809     goto MATCH_finished_a; 
33810     
33811   MATCH_label_a4: (void)0; /*placeholder for label*/ 
33812     { 
33813       unsigned Eaddr = 1 + addressToPC(MATCH_p);
33814       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
33815       nextPC = 2 + MATCH_p; 
33816       
33817       #line 1192 "machine/pentium/disassembler.m"
33818       
33819 
33820               sprintf (str,  "ADDmrod", DIS_EADDR32, DIS_REG32);
33821 
33822       
33823 
33824       
33825       
33826       
33827     } 
33828     goto MATCH_finished_a; 
33829     
33830   MATCH_label_a5: (void)0; /*placeholder for label*/ 
33831     { 
33832       unsigned Eaddr = 1 + addressToPC(MATCH_p);
33833       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
33834       nextPC = 3 + MATCH_p; 
33835       
33836       #line 1192 "machine/pentium/disassembler.m"
33837       
33838 
33839               sprintf (str,  "ADDmrod", DIS_EADDR32, DIS_REG32);
33840 
33841       
33842 
33843       
33844       
33845       
33846     } 
33847     goto MATCH_finished_a; 
33848     
33849   MATCH_label_a6: (void)0; /*placeholder for label*/ 
33850     { 
33851       unsigned Eaddr = 1 + addressToPC(MATCH_p);
33852       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
33853       nextPC = 7 + MATCH_p; 
33854       
33855       #line 1192 "machine/pentium/disassembler.m"
33856       
33857 
33858               sprintf (str,  "ADDmrod", DIS_EADDR32, DIS_REG32);
33859 
33860       
33861 
33862       
33863       
33864       
33865     } 
33866     goto MATCH_finished_a; 
33867     
33868   MATCH_label_a7: (void)0; /*placeholder for label*/ 
33869     { 
33870       unsigned Eaddr = 1 + addressToPC(MATCH_p);
33871       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
33872       nextPC = 6 + MATCH_p; 
33873       
33874       #line 1192 "machine/pentium/disassembler.m"
33875       
33876 
33877               sprintf (str,  "ADDmrod", DIS_EADDR32, DIS_REG32);
33878 
33879       
33880 
33881       
33882       
33883       
33884     } 
33885     goto MATCH_finished_a; 
33886     
33887   MATCH_label_a8: (void)0; /*placeholder for label*/ 
33888     { 
33889       unsigned Eaddr = 1 + addressToPC(MATCH_p);
33890       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
33891       nextPC = 2 + MATCH_p; 
33892       
33893       #line 1147 "machine/pentium/disassembler.m"
33894       
33895 
33896               sprintf (str,  "ADDrmb", DIS_R8, DIS_EADDR8);
33897 
33898       
33899 
33900       
33901       
33902       
33903     } 
33904     goto MATCH_finished_a; 
33905     
33906   MATCH_label_a9: (void)0; /*placeholder for label*/ 
33907     { 
33908       unsigned Eaddr = 1 + addressToPC(MATCH_p);
33909       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
33910       nextPC = 3 + MATCH_p; 
33911       
33912       #line 1147 "machine/pentium/disassembler.m"
33913       
33914 
33915               sprintf (str,  "ADDrmb", DIS_R8, DIS_EADDR8);
33916 
33917       
33918 
33919       
33920       
33921       
33922     } 
33923     goto MATCH_finished_a; 
33924     
33925   MATCH_label_a10: (void)0; /*placeholder for label*/ 
33926     { 
33927       unsigned Eaddr = 1 + addressToPC(MATCH_p);
33928       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
33929       nextPC = 7 + MATCH_p; 
33930       
33931       #line 1147 "machine/pentium/disassembler.m"
33932       
33933 
33934               sprintf (str,  "ADDrmb", DIS_R8, DIS_EADDR8);
33935 
33936       
33937 
33938       
33939       
33940       
33941     } 
33942     goto MATCH_finished_a; 
33943     
33944   MATCH_label_a11: (void)0; /*placeholder for label*/ 
33945     { 
33946       unsigned Eaddr = 1 + addressToPC(MATCH_p);
33947       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
33948       nextPC = 6 + MATCH_p; 
33949       
33950       #line 1147 "machine/pentium/disassembler.m"
33951       
33952 
33953               sprintf (str,  "ADDrmb", DIS_R8, DIS_EADDR8);
33954 
33955       
33956 
33957       
33958       
33959       
33960     } 
33961     goto MATCH_finished_a; 
33962     
33963   MATCH_label_a12: (void)0; /*placeholder for label*/ 
33964     { 
33965       unsigned Eaddr = 1 + addressToPC(MATCH_p);
33966       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
33967       nextPC = 2 + MATCH_p; 
33968       
33969       #line 1120 "machine/pentium/disassembler.m"
33970       
33971 
33972               sprintf (str,  "ADDrmod", DIS_REG32, DIS_EADDR32);
33973 
33974       
33975 
33976       
33977       
33978       
33979     } 
33980     goto MATCH_finished_a; 
33981     
33982   MATCH_label_a13: (void)0; /*placeholder for label*/ 
33983     { 
33984       unsigned Eaddr = 1 + addressToPC(MATCH_p);
33985       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
33986       nextPC = 3 + MATCH_p; 
33987       
33988       #line 1120 "machine/pentium/disassembler.m"
33989       
33990 
33991               sprintf (str,  "ADDrmod", DIS_REG32, DIS_EADDR32);
33992 
33993       
33994 
33995       
33996       
33997       
33998     } 
33999     goto MATCH_finished_a; 
34000     
34001   MATCH_label_a14: (void)0; /*placeholder for label*/ 
34002     { 
34003       unsigned Eaddr = 1 + addressToPC(MATCH_p);
34004       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
34005       nextPC = 7 + MATCH_p; 
34006       
34007       #line 1120 "machine/pentium/disassembler.m"
34008       
34009 
34010               sprintf (str,  "ADDrmod", DIS_REG32, DIS_EADDR32);
34011 
34012       
34013 
34014       
34015       
34016       
34017     } 
34018     goto MATCH_finished_a; 
34019     
34020   MATCH_label_a15: (void)0; /*placeholder for label*/ 
34021     { 
34022       unsigned Eaddr = 1 + addressToPC(MATCH_p);
34023       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
34024       nextPC = 6 + MATCH_p; 
34025       
34026       #line 1120 "machine/pentium/disassembler.m"
34027       
34028 
34029               sprintf (str,  "ADDrmod", DIS_REG32, DIS_EADDR32);
34030 
34031       
34032 
34033       
34034       
34035       
34036     } 
34037     goto MATCH_finished_a; 
34038     
34039   MATCH_label_a16: (void)0; /*placeholder for label*/ 
34040     { 
34041       unsigned Eaddr = 1 + addressToPC(MATCH_p);
34042       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
34043       nextPC = 2 + MATCH_p; 
34044       
34045       #line 1216 "machine/pentium/disassembler.m"
34046       
34047 
34048               sprintf (str,  "ORmrb", DIS_EADDR8, DIS_R8);
34049 
34050       
34051 
34052       
34053       
34054       
34055     } 
34056     goto MATCH_finished_a; 
34057     
34058   MATCH_label_a17: (void)0; /*placeholder for label*/ 
34059     { 
34060       unsigned Eaddr = 1 + addressToPC(MATCH_p);
34061       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
34062       nextPC = 3 + MATCH_p; 
34063       
34064       #line 1216 "machine/pentium/disassembler.m"
34065       
34066 
34067               sprintf (str,  "ORmrb", DIS_EADDR8, DIS_R8);
34068 
34069       
34070 
34071       
34072       
34073       
34074     } 
34075     goto MATCH_finished_a; 
34076     
34077   MATCH_label_a18: (void)0; /*placeholder for label*/ 
34078     { 
34079       unsigned Eaddr = 1 + addressToPC(MATCH_p);
34080       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
34081       nextPC = 7 + MATCH_p; 
34082       
34083       #line 1216 "machine/pentium/disassembler.m"
34084       
34085 
34086               sprintf (str,  "ORmrb", DIS_EADDR8, DIS_R8);
34087 
34088       
34089 
34090       
34091       
34092       
34093     } 
34094     goto MATCH_finished_a; 
34095     
34096   MATCH_label_a19: (void)0; /*placeholder for label*/ 
34097     { 
34098       unsigned Eaddr = 1 + addressToPC(MATCH_p);
34099       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
34100       nextPC = 6 + MATCH_p; 
34101       
34102       #line 1216 "machine/pentium/disassembler.m"
34103       
34104 
34105               sprintf (str,  "ORmrb", DIS_EADDR8, DIS_R8);
34106 
34107       
34108 
34109       
34110       
34111       
34112     } 
34113     goto MATCH_finished_a; 
34114     
34115   MATCH_label_a20: (void)0; /*placeholder for label*/ 
34116     { 
34117       unsigned Eaddr = 1 + addressToPC(MATCH_p);
34118       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
34119       nextPC = 2 + MATCH_p; 
34120       
34121       #line 1186 "machine/pentium/disassembler.m"
34122       
34123 
34124               sprintf (str,  "ORmrod", DIS_EADDR32, DIS_REG32);
34125 
34126       
34127 
34128       
34129       
34130       
34131     } 
34132     goto MATCH_finished_a; 
34133     
34134   MATCH_label_a21: (void)0; /*placeholder for label*/ 
34135     { 
34136       unsigned Eaddr = 1 + addressToPC(MATCH_p);
34137       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
34138       nextPC = 3 + MATCH_p; 
34139       
34140       #line 1186 "machine/pentium/disassembler.m"
34141       
34142 
34143               sprintf (str,  "ORmrod", DIS_EADDR32, DIS_REG32);
34144 
34145       
34146 
34147       
34148       
34149       
34150     } 
34151     goto MATCH_finished_a; 
34152     
34153   MATCH_label_a22: (void)0; /*placeholder for label*/ 
34154     { 
34155       unsigned Eaddr = 1 + addressToPC(MATCH_p);
34156       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
34157       nextPC = 7 + MATCH_p; 
34158       
34159       #line 1186 "machine/pentium/disassembler.m"
34160       
34161 
34162               sprintf (str,  "ORmrod", DIS_EADDR32, DIS_REG32);
34163 
34164       
34165 
34166       
34167       
34168       
34169     } 
34170     goto MATCH_finished_a; 
34171     
34172   MATCH_label_a23: (void)0; /*placeholder for label*/ 
34173     { 
34174       unsigned Eaddr = 1 + addressToPC(MATCH_p);
34175       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
34176       nextPC = 6 + MATCH_p; 
34177       
34178       #line 1186 "machine/pentium/disassembler.m"
34179       
34180 
34181               sprintf (str,  "ORmrod", DIS_EADDR32, DIS_REG32);
34182 
34183       
34184 
34185       
34186       
34187       
34188     } 
34189     goto MATCH_finished_a; 
34190     
34191   MATCH_label_a24: (void)0; /*placeholder for label*/ 
34192     { 
34193       unsigned Eaddr = 1 + addressToPC(MATCH_p);
34194       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
34195       nextPC = 2 + MATCH_p; 
34196       
34197       #line 1144 "machine/pentium/disassembler.m"
34198       
34199 
34200               sprintf (str,  "ORrmb", DIS_R8, DIS_EADDR8);
34201 
34202       
34203 
34204       
34205       
34206       
34207     } 
34208     goto MATCH_finished_a; 
34209     
34210   MATCH_label_a25: (void)0; /*placeholder for label*/ 
34211     { 
34212       unsigned Eaddr = 1 + addressToPC(MATCH_p);
34213       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
34214       nextPC = 3 + MATCH_p; 
34215       
34216       #line 1144 "machine/pentium/disassembler.m"
34217       
34218 
34219               sprintf (str,  "ORrmb", DIS_R8, DIS_EADDR8);
34220 
34221       
34222 
34223       
34224       
34225       
34226     } 
34227     goto MATCH_finished_a; 
34228     
34229   MATCH_label_a26: (void)0; /*placeholder for label*/ 
34230     { 
34231       unsigned Eaddr = 1 + addressToPC(MATCH_p);
34232       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
34233       nextPC = 7 + MATCH_p; 
34234       
34235       #line 1144 "machine/pentium/disassembler.m"
34236       
34237 
34238               sprintf (str,  "ORrmb", DIS_R8, DIS_EADDR8);
34239 
34240       
34241 
34242       
34243       
34244       
34245     } 
34246     goto MATCH_finished_a; 
34247     
34248   MATCH_label_a27: (void)0; /*placeholder for label*/ 
34249     { 
34250       unsigned Eaddr = 1 + addressToPC(MATCH_p);
34251       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
34252       nextPC = 6 + MATCH_p; 
34253       
34254       #line 1144 "machine/pentium/disassembler.m"
34255       
34256 
34257               sprintf (str,  "ORrmb", DIS_R8, DIS_EADDR8);
34258 
34259       
34260 
34261       
34262       
34263       
34264     } 
34265     goto MATCH_finished_a; 
34266     
34267   MATCH_label_a28: (void)0; /*placeholder for label*/ 
34268     { 
34269       unsigned Eaddr = 1 + addressToPC(MATCH_p);
34270       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
34271       nextPC = 2 + MATCH_p; 
34272       
34273       #line 1114 "machine/pentium/disassembler.m"
34274       
34275 
34276               sprintf (str,  "ORrmod", DIS_REG32, DIS_EADDR32);
34277 
34278       
34279 
34280       
34281       
34282       
34283     } 
34284     goto MATCH_finished_a; 
34285     
34286   MATCH_label_a29: (void)0; /*placeholder for label*/ 
34287     { 
34288       unsigned Eaddr = 1 + addressToPC(MATCH_p);
34289       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
34290       nextPC = 3 + MATCH_p; 
34291       
34292       #line 1114 "machine/pentium/disassembler.m"
34293       
34294 
34295               sprintf (str,  "ORrmod", DIS_REG32, DIS_EADDR32);
34296 
34297       
34298 
34299       
34300       
34301       
34302     } 
34303     goto MATCH_finished_a; 
34304     
34305   MATCH_label_a30: (void)0; /*placeholder for label*/ 
34306     { 
34307       unsigned Eaddr = 1 + addressToPC(MATCH_p);
34308       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
34309       nextPC = 7 + MATCH_p; 
34310       
34311       #line 1114 "machine/pentium/disassembler.m"
34312       
34313 
34314               sprintf (str,  "ORrmod", DIS_REG32, DIS_EADDR32);
34315 
34316       
34317 
34318       
34319       
34320       
34321     } 
34322     goto MATCH_finished_a; 
34323     
34324   MATCH_label_a31: (void)0; /*placeholder for label*/ 
34325     { 
34326       unsigned Eaddr = 1 + addressToPC(MATCH_p);
34327       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
34328       nextPC = 6 + MATCH_p; 
34329       
34330       #line 1114 "machine/pentium/disassembler.m"
34331       
34332 
34333               sprintf (str,  "ORrmod", DIS_REG32, DIS_EADDR32);
34334 
34335       
34336 
34337       
34338       
34339       
34340     } 
34341     goto MATCH_finished_a; 
34342     
34343   MATCH_label_a32: (void)0; /*placeholder for label*/ 
34344     { 
34345       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34346       nextPC = 3 + MATCH_p; 
34347       
34348       #line 146 "machine/pentium/disassembler.m"
34349       
34350 
34351               sprintf (str,  "SLDT", DIS_EADDR32);
34352 
34353       
34354 
34355       
34356       
34357       
34358     } 
34359     goto MATCH_finished_a; 
34360     
34361   MATCH_label_a33: (void)0; /*placeholder for label*/ 
34362     { 
34363       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34364       nextPC = 4 + MATCH_p; 
34365       
34366       #line 146 "machine/pentium/disassembler.m"
34367       
34368 
34369               sprintf (str,  "SLDT", DIS_EADDR32);
34370 
34371       
34372 
34373       
34374       
34375       
34376     } 
34377     goto MATCH_finished_a; 
34378     
34379   MATCH_label_a34: (void)0; /*placeholder for label*/ 
34380     { 
34381       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34382       nextPC = 8 + MATCH_p; 
34383       
34384       #line 146 "machine/pentium/disassembler.m"
34385       
34386 
34387               sprintf (str,  "SLDT", DIS_EADDR32);
34388 
34389       
34390 
34391       
34392       
34393       
34394     } 
34395     goto MATCH_finished_a; 
34396     
34397   MATCH_label_a35: (void)0; /*placeholder for label*/ 
34398     { 
34399       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34400       nextPC = 7 + MATCH_p; 
34401       
34402       #line 146 "machine/pentium/disassembler.m"
34403       
34404 
34405               sprintf (str,  "SLDT", DIS_EADDR32);
34406 
34407       
34408 
34409       
34410       
34411       
34412     } 
34413     goto MATCH_finished_a; 
34414     
34415   MATCH_label_a36: (void)0; /*placeholder for label*/ 
34416     { 
34417       unsigned Mem = 2 + addressToPC(MATCH_p);
34418       nextPC = 4 + MATCH_p; 
34419       
34420       #line 122 "machine/pentium/disassembler.m"
34421       
34422 
34423               sprintf (str,  "STR", DIS_MEM);
34424 
34425       
34426 
34427       
34428       
34429       
34430     } 
34431     goto MATCH_finished_a; 
34432     
34433   MATCH_label_a37: (void)0; /*placeholder for label*/ 
34434     { 
34435       unsigned Mem = 2 + addressToPC(MATCH_p);
34436       nextPC = 8 + MATCH_p; 
34437       
34438       #line 122 "machine/pentium/disassembler.m"
34439       
34440 
34441               sprintf (str,  "STR", DIS_MEM);
34442 
34443       
34444 
34445       
34446       
34447       
34448     } 
34449     goto MATCH_finished_a; 
34450     
34451   MATCH_label_a38: (void)0; /*placeholder for label*/ 
34452     { 
34453       unsigned Mem = 2 + addressToPC(MATCH_p);
34454       nextPC = 7 + MATCH_p; 
34455       
34456       #line 122 "machine/pentium/disassembler.m"
34457       
34458 
34459               sprintf (str,  "STR", DIS_MEM);
34460 
34461       
34462 
34463       
34464       
34465       
34466     } 
34467     goto MATCH_finished_a; 
34468     
34469   MATCH_label_a39: (void)0; /*placeholder for label*/ 
34470     { 
34471       nextPC = MATCH_p; 
34472       
34473       #line 1792 "machine/pentium/disassembler.m"
34474       
34475             sprintf (str, "%0x", n);
34476 
34477       
34478 
34479       
34480       
34481       
34482     } 
34483     goto MATCH_finished_a; 
34484     
34485   MATCH_label_a40: (void)0; /*placeholder for label*/ 
34486     { 
34487       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34488       nextPC = 3 + MATCH_p; 
34489       
34490       #line 745 "machine/pentium/disassembler.m"
34491       
34492 
34493               sprintf (str,  "LTR", DIS_EADDR32);
34494 
34495       
34496 
34497       
34498       
34499       
34500     } 
34501     goto MATCH_finished_a; 
34502     
34503   MATCH_label_a41: (void)0; /*placeholder for label*/ 
34504     { 
34505       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34506       nextPC = 4 + MATCH_p; 
34507       
34508       #line 745 "machine/pentium/disassembler.m"
34509       
34510 
34511               sprintf (str,  "LTR", DIS_EADDR32);
34512 
34513       
34514 
34515       
34516       
34517       
34518     } 
34519     goto MATCH_finished_a; 
34520     
34521   MATCH_label_a42: (void)0; /*placeholder for label*/ 
34522     { 
34523       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34524       nextPC = 8 + MATCH_p; 
34525       
34526       #line 745 "machine/pentium/disassembler.m"
34527       
34528 
34529               sprintf (str,  "LTR", DIS_EADDR32);
34530 
34531       
34532 
34533       
34534       
34535       
34536     } 
34537     goto MATCH_finished_a; 
34538     
34539   MATCH_label_a43: (void)0; /*placeholder for label*/ 
34540     { 
34541       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34542       nextPC = 7 + MATCH_p; 
34543       
34544       #line 745 "machine/pentium/disassembler.m"
34545       
34546 
34547               sprintf (str,  "LTR", DIS_EADDR32);
34548 
34549       
34550 
34551       
34552       
34553       
34554     } 
34555     goto MATCH_finished_a; 
34556     
34557   MATCH_label_a44: (void)0; /*placeholder for label*/ 
34558     { 
34559       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34560       nextPC = 3 + MATCH_p; 
34561       
34562       #line 92 "machine/pentium/disassembler.m"
34563       
34564 
34565               sprintf (str,  "VERR", DIS_EADDR32);
34566 
34567       
34568 
34569       
34570       
34571       
34572     } 
34573     goto MATCH_finished_a; 
34574     
34575   MATCH_label_a45: (void)0; /*placeholder for label*/ 
34576     { 
34577       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34578       nextPC = 4 + MATCH_p; 
34579       
34580       #line 92 "machine/pentium/disassembler.m"
34581       
34582 
34583               sprintf (str,  "VERR", DIS_EADDR32);
34584 
34585       
34586 
34587       
34588       
34589       
34590     } 
34591     goto MATCH_finished_a; 
34592     
34593   MATCH_label_a46: (void)0; /*placeholder for label*/ 
34594     { 
34595       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34596       nextPC = 8 + MATCH_p; 
34597       
34598       #line 92 "machine/pentium/disassembler.m"
34599       
34600 
34601               sprintf (str,  "VERR", DIS_EADDR32);
34602 
34603       
34604 
34605       
34606       
34607       
34608     } 
34609     goto MATCH_finished_a; 
34610     
34611   MATCH_label_a47: (void)0; /*placeholder for label*/ 
34612     { 
34613       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34614       nextPC = 7 + MATCH_p; 
34615       
34616       #line 92 "machine/pentium/disassembler.m"
34617       
34618 
34619               sprintf (str,  "VERR", DIS_EADDR32);
34620 
34621       
34622 
34623       
34624       
34625       
34626     } 
34627     goto MATCH_finished_a; 
34628     
34629   MATCH_label_a48: (void)0; /*placeholder for label*/ 
34630     { 
34631       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34632       nextPC = 3 + MATCH_p; 
34633       
34634       #line 89 "machine/pentium/disassembler.m"
34635       
34636 
34637               sprintf (str,  "VERW", DIS_EADDR32);
34638 
34639       
34640 
34641       
34642       
34643       
34644     } 
34645     goto MATCH_finished_a; 
34646     
34647   MATCH_label_a49: (void)0; /*placeholder for label*/ 
34648     { 
34649       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34650       nextPC = 4 + MATCH_p; 
34651       
34652       #line 89 "machine/pentium/disassembler.m"
34653       
34654 
34655               sprintf (str,  "VERW", DIS_EADDR32);
34656 
34657       
34658 
34659       
34660       
34661       
34662     } 
34663     goto MATCH_finished_a; 
34664     
34665   MATCH_label_a50: (void)0; /*placeholder for label*/ 
34666     { 
34667       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34668       nextPC = 8 + MATCH_p; 
34669       
34670       #line 89 "machine/pentium/disassembler.m"
34671       
34672 
34673               sprintf (str,  "VERW", DIS_EADDR32);
34674 
34675       
34676 
34677       
34678       
34679       
34680     } 
34681     goto MATCH_finished_a; 
34682     
34683   MATCH_label_a51: (void)0; /*placeholder for label*/ 
34684     { 
34685       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34686       nextPC = 7 + MATCH_p; 
34687       
34688       #line 89 "machine/pentium/disassembler.m"
34689       
34690 
34691               sprintf (str,  "VERW", DIS_EADDR32);
34692 
34693       
34694 
34695       
34696       
34697       
34698     } 
34699     goto MATCH_finished_a; 
34700     
34701   MATCH_label_a52: (void)0; /*placeholder for label*/ 
34702     { 
34703       unsigned Mem = 2 + addressToPC(MATCH_p);
34704       nextPC = 4 + MATCH_p; 
34705       
34706       #line 176 "machine/pentium/disassembler.m"
34707       
34708 
34709               sprintf (str,  "SGDT", DIS_MEM);
34710 
34711       
34712 
34713           // Sets are now in the high level instructions
34714 
34715       
34716       
34717       
34718     } 
34719     goto MATCH_finished_a; 
34720     
34721   MATCH_label_a53: (void)0; /*placeholder for label*/ 
34722     { 
34723       unsigned Mem = 2 + addressToPC(MATCH_p);
34724       nextPC = 8 + MATCH_p; 
34725       
34726       #line 176 "machine/pentium/disassembler.m"
34727       
34728 
34729               sprintf (str,  "SGDT", DIS_MEM);
34730 
34731       
34732 
34733           // Sets are now in the high level instructions
34734 
34735       
34736       
34737       
34738     } 
34739     goto MATCH_finished_a; 
34740     
34741   MATCH_label_a54: (void)0; /*placeholder for label*/ 
34742     { 
34743       unsigned Mem = 2 + addressToPC(MATCH_p);
34744       nextPC = 7 + MATCH_p; 
34745       
34746       #line 176 "machine/pentium/disassembler.m"
34747       
34748 
34749               sprintf (str,  "SGDT", DIS_MEM);
34750 
34751       
34752 
34753           // Sets are now in the high level instructions
34754 
34755       
34756       
34757       
34758     } 
34759     goto MATCH_finished_a; 
34760     
34761   MATCH_label_a55: (void)0; /*placeholder for label*/ 
34762     { 
34763       unsigned Mem = 2 + addressToPC(MATCH_p);
34764       nextPC = 4 + MATCH_p; 
34765       
34766       #line 173 "machine/pentium/disassembler.m"
34767       
34768 
34769               sprintf (str,  "SIDT", DIS_MEM);
34770 
34771       
34772 
34773       
34774       
34775       
34776     } 
34777     goto MATCH_finished_a; 
34778     
34779   MATCH_label_a56: (void)0; /*placeholder for label*/ 
34780     { 
34781       unsigned Mem = 2 + addressToPC(MATCH_p);
34782       nextPC = 8 + MATCH_p; 
34783       
34784       #line 173 "machine/pentium/disassembler.m"
34785       
34786 
34787               sprintf (str,  "SIDT", DIS_MEM);
34788 
34789       
34790 
34791       
34792       
34793       
34794     } 
34795     goto MATCH_finished_a; 
34796     
34797   MATCH_label_a57: (void)0; /*placeholder for label*/ 
34798     { 
34799       unsigned Mem = 2 + addressToPC(MATCH_p);
34800       nextPC = 7 + MATCH_p; 
34801       
34802       #line 173 "machine/pentium/disassembler.m"
34803       
34804 
34805               sprintf (str,  "SIDT", DIS_MEM);
34806 
34807       
34808 
34809       
34810       
34811       
34812     } 
34813     goto MATCH_finished_a; 
34814     
34815   MATCH_label_a58: (void)0; /*placeholder for label*/ 
34816     { 
34817       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34818       nextPC = 3 + MATCH_p; 
34819       
34820       #line 143 "machine/pentium/disassembler.m"
34821       
34822 
34823               sprintf (str,  "SMSW", DIS_EADDR32);
34824 
34825       
34826 
34827       
34828       
34829       
34830     } 
34831     goto MATCH_finished_a; 
34832     
34833   MATCH_label_a59: (void)0; /*placeholder for label*/ 
34834     { 
34835       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34836       nextPC = 4 + MATCH_p; 
34837       
34838       #line 143 "machine/pentium/disassembler.m"
34839       
34840 
34841               sprintf (str,  "SMSW", DIS_EADDR32);
34842 
34843       
34844 
34845       
34846       
34847       
34848     } 
34849     goto MATCH_finished_a; 
34850     
34851   MATCH_label_a60: (void)0; /*placeholder for label*/ 
34852     { 
34853       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34854       nextPC = 8 + MATCH_p; 
34855       
34856       #line 143 "machine/pentium/disassembler.m"
34857       
34858 
34859               sprintf (str,  "SMSW", DIS_EADDR32);
34860 
34861       
34862 
34863       
34864       
34865       
34866     } 
34867     goto MATCH_finished_a; 
34868     
34869   MATCH_label_a61: (void)0; /*placeholder for label*/ 
34870     { 
34871       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34872       nextPC = 7 + MATCH_p; 
34873       
34874       #line 143 "machine/pentium/disassembler.m"
34875       
34876 
34877               sprintf (str,  "SMSW", DIS_EADDR32);
34878 
34879       
34880 
34881       
34882       
34883       
34884     } 
34885     goto MATCH_finished_a; 
34886     
34887   MATCH_label_a62: (void)0; /*placeholder for label*/ 
34888     { 
34889       unsigned Mem = 2 + addressToPC(MATCH_p);
34890       nextPC = 4 + MATCH_p; 
34891       
34892       #line 800 "machine/pentium/disassembler.m"
34893       
34894 
34895               sprintf (str,  "INVLPG", DIS_MEM);
34896 
34897       
34898 
34899       
34900       
34901       
34902     } 
34903     goto MATCH_finished_a; 
34904     
34905   MATCH_label_a63: (void)0; /*placeholder for label*/ 
34906     { 
34907       unsigned Mem = 2 + addressToPC(MATCH_p);
34908       nextPC = 8 + MATCH_p; 
34909       
34910       #line 800 "machine/pentium/disassembler.m"
34911       
34912 
34913               sprintf (str,  "INVLPG", DIS_MEM);
34914 
34915       
34916 
34917       
34918       
34919       
34920     } 
34921     goto MATCH_finished_a; 
34922     
34923   MATCH_label_a64: (void)0; /*placeholder for label*/ 
34924     { 
34925       unsigned Mem = 2 + addressToPC(MATCH_p);
34926       nextPC = 7 + MATCH_p; 
34927       
34928       #line 800 "machine/pentium/disassembler.m"
34929       
34930 
34931               sprintf (str,  "INVLPG", DIS_MEM);
34932 
34933       
34934 
34935       
34936       
34937       
34938     } 
34939     goto MATCH_finished_a; 
34940     
34941   MATCH_label_a65: (void)0; /*placeholder for label*/ 
34942     { 
34943       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34944       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
34945       nextPC = 3 + MATCH_p; 
34946       
34947       #line 787 "machine/pentium/disassembler.m"
34948       
34949 
34950               sprintf (str,  "LAR.od", DIS_REG32, DIS_EADDR32);
34951 
34952       
34953 
34954       
34955       
34956       
34957     } 
34958     goto MATCH_finished_a; 
34959     
34960   MATCH_label_a66: (void)0; /*placeholder for label*/ 
34961     { 
34962       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34963       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
34964       nextPC = 4 + MATCH_p; 
34965       
34966       #line 787 "machine/pentium/disassembler.m"
34967       
34968 
34969               sprintf (str,  "LAR.od", DIS_REG32, DIS_EADDR32);
34970 
34971       
34972 
34973       
34974       
34975       
34976     } 
34977     goto MATCH_finished_a; 
34978     
34979   MATCH_label_a67: (void)0; /*placeholder for label*/ 
34980     { 
34981       unsigned Eaddr = 2 + addressToPC(MATCH_p);
34982       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
34983       nextPC = 8 + MATCH_p; 
34984       
34985       #line 787 "machine/pentium/disassembler.m"
34986       
34987 
34988               sprintf (str,  "LAR.od", DIS_REG32, DIS_EADDR32);
34989 
34990       
34991 
34992       
34993       
34994       
34995     } 
34996     goto MATCH_finished_a; 
34997     
34998   MATCH_label_a68: (void)0; /*placeholder for label*/ 
34999     { 
35000       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35001       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35002       nextPC = 7 + MATCH_p; 
35003       
35004       #line 787 "machine/pentium/disassembler.m"
35005       
35006 
35007               sprintf (str,  "LAR.od", DIS_REG32, DIS_EADDR32);
35008 
35009       
35010 
35011       
35012       
35013       
35014     } 
35015     goto MATCH_finished_a; 
35016     
35017   MATCH_label_a69: (void)0; /*placeholder for label*/ 
35018     { 
35019       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35020       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35021       nextPC = 3 + MATCH_p; 
35022       
35023       #line 751 "machine/pentium/disassembler.m"
35024       
35025 
35026               sprintf (str,  "LSLod", DIS_REG32, DIS_EADDR32);
35027 
35028       
35029 
35030       
35031       
35032       
35033     } 
35034     goto MATCH_finished_a; 
35035     
35036   MATCH_label_a70: (void)0; /*placeholder for label*/ 
35037     { 
35038       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35039       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35040       nextPC = 4 + MATCH_p; 
35041       
35042       #line 751 "machine/pentium/disassembler.m"
35043       
35044 
35045               sprintf (str,  "LSLod", DIS_REG32, DIS_EADDR32);
35046 
35047       
35048 
35049       
35050       
35051       
35052     } 
35053     goto MATCH_finished_a; 
35054     
35055   MATCH_label_a71: (void)0; /*placeholder for label*/ 
35056     { 
35057       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35058       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35059       nextPC = 8 + MATCH_p; 
35060       
35061       #line 751 "machine/pentium/disassembler.m"
35062       
35063 
35064               sprintf (str,  "LSLod", DIS_REG32, DIS_EADDR32);
35065 
35066       
35067 
35068       
35069       
35070       
35071     } 
35072     goto MATCH_finished_a; 
35073     
35074   MATCH_label_a72: (void)0; /*placeholder for label*/ 
35075     { 
35076       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35077       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35078       nextPC = 7 + MATCH_p; 
35079       
35080       #line 751 "machine/pentium/disassembler.m"
35081       
35082 
35083               sprintf (str,  "LSLod", DIS_REG32, DIS_EADDR32);
35084 
35085       
35086 
35087       
35088       
35089       
35090     } 
35091     goto MATCH_finished_a; 
35092     
35093   MATCH_label_a73: (void)0; /*placeholder for label*/ 
35094     { 
35095       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35096       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35097       nextPC = 3 + MATCH_p; 
35098       
35099       #line 1034 "machine/pentium/disassembler.m"
35100       
35101 
35102               sprintf (str,  "BTod", DIS_EADDR32, DIS_REG32);
35103 
35104       
35105 
35106       
35107       
35108       
35109     } 
35110     goto MATCH_finished_a; 
35111     
35112   MATCH_label_a74: (void)0; /*placeholder for label*/ 
35113     { 
35114       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35115       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35116       nextPC = 4 + MATCH_p; 
35117       
35118       #line 1034 "machine/pentium/disassembler.m"
35119       
35120 
35121               sprintf (str,  "BTod", DIS_EADDR32, DIS_REG32);
35122 
35123       
35124 
35125       
35126       
35127       
35128     } 
35129     goto MATCH_finished_a; 
35130     
35131   MATCH_label_a75: (void)0; /*placeholder for label*/ 
35132     { 
35133       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35134       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35135       nextPC = 8 + MATCH_p; 
35136       
35137       #line 1034 "machine/pentium/disassembler.m"
35138       
35139 
35140               sprintf (str,  "BTod", DIS_EADDR32, DIS_REG32);
35141 
35142       
35143 
35144       
35145       
35146       
35147     } 
35148     goto MATCH_finished_a; 
35149     
35150   MATCH_label_a76: (void)0; /*placeholder for label*/ 
35151     { 
35152       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35153       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35154       nextPC = 7 + MATCH_p; 
35155       
35156       #line 1034 "machine/pentium/disassembler.m"
35157       
35158 
35159               sprintf (str,  "BTod", DIS_EADDR32, DIS_REG32);
35160 
35161       
35162 
35163       
35164       
35165       
35166     } 
35167     goto MATCH_finished_a; 
35168     
35169   MATCH_label_a77: (void)0; /*placeholder for label*/ 
35170     { 
35171       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35172       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35173       nextPC = 3 + MATCH_p; 
35174       
35175       #line 998 "machine/pentium/disassembler.m"
35176       
35177 
35178               sprintf (str,  "BTSod", DIS_EADDR32, DIS_REG32);
35179 
35180       
35181 
35182       
35183       
35184       
35185     } 
35186     goto MATCH_finished_a; 
35187     
35188   MATCH_label_a78: (void)0; /*placeholder for label*/ 
35189     { 
35190       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35191       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35192       nextPC = 4 + MATCH_p; 
35193       
35194       #line 998 "machine/pentium/disassembler.m"
35195       
35196 
35197               sprintf (str,  "BTSod", DIS_EADDR32, DIS_REG32);
35198 
35199       
35200 
35201       
35202       
35203       
35204     } 
35205     goto MATCH_finished_a; 
35206     
35207   MATCH_label_a79: (void)0; /*placeholder for label*/ 
35208     { 
35209       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35210       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35211       nextPC = 8 + MATCH_p; 
35212       
35213       #line 998 "machine/pentium/disassembler.m"
35214       
35215 
35216               sprintf (str,  "BTSod", DIS_EADDR32, DIS_REG32);
35217 
35218       
35219 
35220       
35221       
35222       
35223     } 
35224     goto MATCH_finished_a; 
35225     
35226   MATCH_label_a80: (void)0; /*placeholder for label*/ 
35227     { 
35228       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35229       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35230       nextPC = 7 + MATCH_p; 
35231       
35232       #line 998 "machine/pentium/disassembler.m"
35233       
35234 
35235               sprintf (str,  "BTSod", DIS_EADDR32, DIS_REG32);
35236 
35237       
35238 
35239       
35240       
35241       
35242     } 
35243     goto MATCH_finished_a; 
35244     
35245   MATCH_label_a81: (void)0; /*placeholder for label*/ 
35246     { 
35247       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35248       unsigned count = (MATCH_w_8_24 & 0xff) /* i8 at 24 */;
35249       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35250       nextPC = 4 + MATCH_p; 
35251       
35252       #line 161 "machine/pentium/disassembler.m"
35253       
35254 
35255               sprintf (str,  "SHLD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
35256 
35257       
35258 
35259       
35260       
35261       
35262     } 
35263     goto MATCH_finished_a; 
35264     
35265   MATCH_label_a82: (void)0; /*placeholder for label*/ 
35266     { 
35267       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35268       unsigned count = (MATCH_w_8_32 & 0xff) /* i8 at 32 */;
35269       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35270       nextPC = 5 + MATCH_p; 
35271       
35272       #line 161 "machine/pentium/disassembler.m"
35273       
35274 
35275               sprintf (str,  "SHLD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
35276 
35277       
35278 
35279       
35280       
35281       
35282     } 
35283     goto MATCH_finished_a; 
35284     
35285   MATCH_label_a83: (void)0; /*placeholder for label*/ 
35286     { 
35287       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35288       unsigned count = (MATCH_w_8_64 & 0xff) /* i8 at 64 */;
35289       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35290       nextPC = 9 + MATCH_p; 
35291       
35292       #line 161 "machine/pentium/disassembler.m"
35293       
35294 
35295               sprintf (str,  "SHLD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
35296 
35297       
35298 
35299       
35300       
35301       
35302     } 
35303     goto MATCH_finished_a; 
35304     
35305   MATCH_label_a84: (void)0; /*placeholder for label*/ 
35306     { 
35307       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35308       unsigned count = (MATCH_w_8_56 & 0xff) /* i8 at 56 */;
35309       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35310       nextPC = 8 + MATCH_p; 
35311       
35312       #line 161 "machine/pentium/disassembler.m"
35313       
35314 
35315               sprintf (str,  "SHLD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
35316 
35317       
35318 
35319       
35320       
35321       
35322     } 
35323     goto MATCH_finished_a; 
35324     
35325   MATCH_label_a85: (void)0; /*placeholder for label*/ 
35326     { 
35327       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35328       unsigned count = (MATCH_w_8_24 & 0xff) /* i8 at 24 */;
35329       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35330       nextPC = 4 + MATCH_p; 
35331       
35332       #line 167 "machine/pentium/disassembler.m"
35333       
35334 
35335               sprintf (str,  "SHRD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
35336 
35337       
35338 
35339       
35340       
35341       
35342     } 
35343     goto MATCH_finished_a; 
35344     
35345   MATCH_label_a86: (void)0; /*placeholder for label*/ 
35346     { 
35347       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35348       unsigned count = (MATCH_w_8_32 & 0xff) /* i8 at 32 */;
35349       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35350       nextPC = 5 + MATCH_p; 
35351       
35352       #line 167 "machine/pentium/disassembler.m"
35353       
35354 
35355               sprintf (str,  "SHRD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
35356 
35357       
35358 
35359       
35360       
35361       
35362     } 
35363     goto MATCH_finished_a; 
35364     
35365   MATCH_label_a87: (void)0; /*placeholder for label*/ 
35366     { 
35367       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35368       unsigned count = (MATCH_w_8_64 & 0xff) /* i8 at 64 */;
35369       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35370       nextPC = 9 + MATCH_p; 
35371       
35372       #line 167 "machine/pentium/disassembler.m"
35373       
35374 
35375               sprintf (str,  "SHRD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
35376 
35377       
35378 
35379       
35380       
35381       
35382     } 
35383     goto MATCH_finished_a; 
35384     
35385   MATCH_label_a88: (void)0; /*placeholder for label*/ 
35386     { 
35387       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35388       unsigned count = (MATCH_w_8_56 & 0xff) /* i8 at 56 */;
35389       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35390       nextPC = 8 + MATCH_p; 
35391       
35392       #line 167 "machine/pentium/disassembler.m"
35393       
35394 
35395               sprintf (str,  "SHRD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
35396 
35397       
35398 
35399       
35400       
35401       
35402     } 
35403     goto MATCH_finished_a; 
35404     
35405   MATCH_label_a89: (void)0; /*placeholder for label*/ 
35406     { 
35407       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35408       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35409       nextPC = 3 + MATCH_p; 
35410       
35411       #line 149 "machine/pentium/disassembler.m"
35412       
35413 
35414               sprintf (str,  "SHLD.CLod", DIS_EADDR32, DIS_REG32);
35415 
35416       
35417 
35418       
35419       
35420       
35421     } 
35422     goto MATCH_finished_a; 
35423     
35424   MATCH_label_a90: (void)0; /*placeholder for label*/ 
35425     { 
35426       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35427       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35428       nextPC = 4 + MATCH_p; 
35429       
35430       #line 149 "machine/pentium/disassembler.m"
35431       
35432 
35433               sprintf (str,  "SHLD.CLod", DIS_EADDR32, DIS_REG32);
35434 
35435       
35436 
35437       
35438       
35439       
35440     } 
35441     goto MATCH_finished_a; 
35442     
35443   MATCH_label_a91: (void)0; /*placeholder for label*/ 
35444     { 
35445       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35446       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35447       nextPC = 8 + MATCH_p; 
35448       
35449       #line 149 "machine/pentium/disassembler.m"
35450       
35451 
35452               sprintf (str,  "SHLD.CLod", DIS_EADDR32, DIS_REG32);
35453 
35454       
35455 
35456       
35457       
35458       
35459     } 
35460     goto MATCH_finished_a; 
35461     
35462   MATCH_label_a92: (void)0; /*placeholder for label*/ 
35463     { 
35464       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35465       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35466       nextPC = 7 + MATCH_p; 
35467       
35468       #line 149 "machine/pentium/disassembler.m"
35469       
35470 
35471               sprintf (str,  "SHLD.CLod", DIS_EADDR32, DIS_REG32);
35472 
35473       
35474 
35475       
35476       
35477       
35478     } 
35479     goto MATCH_finished_a; 
35480     
35481   MATCH_label_a93: (void)0; /*placeholder for label*/ 
35482     { 
35483       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35484       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35485       nextPC = 3 + MATCH_p; 
35486       
35487       #line 155 "machine/pentium/disassembler.m"
35488       
35489 
35490               sprintf (str,  "SHRD.CLod", DIS_EADDR32, DIS_REG32);
35491 
35492       
35493 
35494       
35495       
35496       
35497     } 
35498     goto MATCH_finished_a; 
35499     
35500   MATCH_label_a94: (void)0; /*placeholder for label*/ 
35501     { 
35502       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35503       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35504       nextPC = 4 + MATCH_p; 
35505       
35506       #line 155 "machine/pentium/disassembler.m"
35507       
35508 
35509               sprintf (str,  "SHRD.CLod", DIS_EADDR32, DIS_REG32);
35510 
35511       
35512 
35513       
35514       
35515       
35516     } 
35517     goto MATCH_finished_a; 
35518     
35519   MATCH_label_a95: (void)0; /*placeholder for label*/ 
35520     { 
35521       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35522       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35523       nextPC = 8 + MATCH_p; 
35524       
35525       #line 155 "machine/pentium/disassembler.m"
35526       
35527 
35528               sprintf (str,  "SHRD.CLod", DIS_EADDR32, DIS_REG32);
35529 
35530       
35531 
35532       
35533       
35534       
35535     } 
35536     goto MATCH_finished_a; 
35537     
35538   MATCH_label_a96: (void)0; /*placeholder for label*/ 
35539     { 
35540       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35541       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35542       nextPC = 7 + MATCH_p; 
35543       
35544       #line 155 "machine/pentium/disassembler.m"
35545       
35546 
35547               sprintf (str,  "SHRD.CLod", DIS_EADDR32, DIS_REG32);
35548 
35549       
35550 
35551       
35552       
35553       
35554     } 
35555     goto MATCH_finished_a; 
35556     
35557   MATCH_label_a97: (void)0; /*placeholder for label*/ 
35558     { 
35559       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35560       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35561       nextPC = 3 + MATCH_p; 
35562       
35563       #line 869 "machine/pentium/disassembler.m"
35564       
35565 
35566               sprintf (str,  "IMULrmod", DIS_REG32, DIS_EADDR32);
35567 
35568       
35569 
35570       
35571       
35572       
35573     } 
35574     goto MATCH_finished_a; 
35575     
35576   MATCH_label_a98: (void)0; /*placeholder for label*/ 
35577     { 
35578       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35579       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35580       nextPC = 4 + MATCH_p; 
35581       
35582       #line 869 "machine/pentium/disassembler.m"
35583       
35584 
35585               sprintf (str,  "IMULrmod", DIS_REG32, DIS_EADDR32);
35586 
35587       
35588 
35589       
35590       
35591       
35592     } 
35593     goto MATCH_finished_a; 
35594     
35595   MATCH_label_a99: (void)0; /*placeholder for label*/ 
35596     { 
35597       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35598       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35599       nextPC = 8 + MATCH_p; 
35600       
35601       #line 869 "machine/pentium/disassembler.m"
35602       
35603 
35604               sprintf (str,  "IMULrmod", DIS_REG32, DIS_EADDR32);
35605 
35606       
35607 
35608       
35609       
35610       
35611     } 
35612     goto MATCH_finished_a; 
35613     
35614   MATCH_label_a100: (void)0; /*placeholder for label*/ 
35615     { 
35616       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35617       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35618       nextPC = 7 + MATCH_p; 
35619       
35620       #line 869 "machine/pentium/disassembler.m"
35621       
35622 
35623               sprintf (str,  "IMULrmod", DIS_REG32, DIS_EADDR32);
35624 
35625       
35626 
35627       
35628       
35629       
35630     } 
35631     goto MATCH_finished_a; 
35632     
35633   MATCH_label_a101: (void)0; /*placeholder for label*/ 
35634     { 
35635       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35636       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35637       nextPC = 3 + MATCH_p; 
35638       
35639       #line 947 "machine/pentium/disassembler.m"
35640       
35641 
35642               sprintf (str,  "CMPXCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
35643 
35644       
35645 
35646       
35647       
35648       
35649     } 
35650     goto MATCH_finished_a; 
35651     
35652   MATCH_label_a102: (void)0; /*placeholder for label*/ 
35653     { 
35654       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35655       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35656       nextPC = 4 + MATCH_p; 
35657       
35658       #line 947 "machine/pentium/disassembler.m"
35659       
35660 
35661               sprintf (str,  "CMPXCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
35662 
35663       
35664 
35665       
35666       
35667       
35668     } 
35669     goto MATCH_finished_a; 
35670     
35671   MATCH_label_a103: (void)0; /*placeholder for label*/ 
35672     { 
35673       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35674       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35675       nextPC = 8 + MATCH_p; 
35676       
35677       #line 947 "machine/pentium/disassembler.m"
35678       
35679 
35680               sprintf (str,  "CMPXCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
35681 
35682       
35683 
35684       
35685       
35686       
35687     } 
35688     goto MATCH_finished_a; 
35689     
35690   MATCH_label_a104: (void)0; /*placeholder for label*/ 
35691     { 
35692       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35693       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35694       nextPC = 7 + MATCH_p; 
35695       
35696       #line 947 "machine/pentium/disassembler.m"
35697       
35698 
35699               sprintf (str,  "CMPXCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
35700 
35701       
35702 
35703       
35704       
35705       
35706     } 
35707     goto MATCH_finished_a; 
35708     
35709   MATCH_label_a105: (void)0; /*placeholder for label*/ 
35710     { 
35711       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35712       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35713       nextPC = 3 + MATCH_p; 
35714       
35715       #line 941 "machine/pentium/disassembler.m"
35716       
35717 
35718               sprintf (str,  "CMPXCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
35719 
35720       
35721 
35722       
35723       
35724       
35725     } 
35726     goto MATCH_finished_a; 
35727     
35728   MATCH_label_a106: (void)0; /*placeholder for label*/ 
35729     { 
35730       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35731       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35732       nextPC = 4 + MATCH_p; 
35733       
35734       #line 941 "machine/pentium/disassembler.m"
35735       
35736 
35737               sprintf (str,  "CMPXCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
35738 
35739       
35740 
35741       
35742       
35743       
35744     } 
35745     goto MATCH_finished_a; 
35746     
35747   MATCH_label_a107: (void)0; /*placeholder for label*/ 
35748     { 
35749       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35750       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35751       nextPC = 8 + MATCH_p; 
35752       
35753       #line 941 "machine/pentium/disassembler.m"
35754       
35755 
35756               sprintf (str,  "CMPXCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
35757 
35758       
35759 
35760       
35761       
35762       
35763     } 
35764     goto MATCH_finished_a; 
35765     
35766   MATCH_label_a108: (void)0; /*placeholder for label*/ 
35767     { 
35768       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35769       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35770       nextPC = 7 + MATCH_p; 
35771       
35772       #line 941 "machine/pentium/disassembler.m"
35773       
35774 
35775               sprintf (str,  "CMPXCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
35776 
35777       
35778 
35779       
35780       
35781       
35782     } 
35783     goto MATCH_finished_a; 
35784     
35785   MATCH_label_a109: (void)0; /*placeholder for label*/ 
35786     { 
35787       unsigned Mem = 2 + addressToPC(MATCH_p);
35788       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35789       nextPC = 4 + MATCH_p; 
35790       
35791       #line 748 "machine/pentium/disassembler.m"
35792       
35793 
35794               sprintf (str,  "LSS", DIS_REG32, DIS_MEM);
35795 
35796       
35797 
35798       
35799       
35800       
35801     } 
35802     goto MATCH_finished_a; 
35803     
35804   MATCH_label_a110: (void)0; /*placeholder for label*/ 
35805     { 
35806       unsigned Mem = 2 + addressToPC(MATCH_p);
35807       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35808       nextPC = 8 + MATCH_p; 
35809       
35810       #line 748 "machine/pentium/disassembler.m"
35811       
35812 
35813               sprintf (str,  "LSS", DIS_REG32, DIS_MEM);
35814 
35815       
35816 
35817       
35818       
35819       
35820     } 
35821     goto MATCH_finished_a; 
35822     
35823   MATCH_label_a111: (void)0; /*placeholder for label*/ 
35824     { 
35825       unsigned Mem = 2 + addressToPC(MATCH_p);
35826       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35827       nextPC = 7 + MATCH_p; 
35828       
35829       #line 748 "machine/pentium/disassembler.m"
35830       
35831 
35832               sprintf (str,  "LSS", DIS_REG32, DIS_MEM);
35833 
35834       
35835 
35836       
35837       
35838       
35839     } 
35840     goto MATCH_finished_a; 
35841     
35842   MATCH_label_a112: (void)0; /*placeholder for label*/ 
35843     { 
35844       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35845       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35846       nextPC = 3 + MATCH_p; 
35847       
35848       #line 1010 "machine/pentium/disassembler.m"
35849       
35850 
35851               sprintf (str,  "BTRod", DIS_EADDR32, DIS_REG32);
35852 
35853       
35854 
35855       
35856       
35857       
35858     } 
35859     goto MATCH_finished_a; 
35860     
35861   MATCH_label_a113: (void)0; /*placeholder for label*/ 
35862     { 
35863       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35864       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35865       nextPC = 4 + MATCH_p; 
35866       
35867       #line 1010 "machine/pentium/disassembler.m"
35868       
35869 
35870               sprintf (str,  "BTRod", DIS_EADDR32, DIS_REG32);
35871 
35872       
35873 
35874       
35875       
35876       
35877     } 
35878     goto MATCH_finished_a; 
35879     
35880   MATCH_label_a114: (void)0; /*placeholder for label*/ 
35881     { 
35882       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35883       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35884       nextPC = 8 + MATCH_p; 
35885       
35886       #line 1010 "machine/pentium/disassembler.m"
35887       
35888 
35889               sprintf (str,  "BTRod", DIS_EADDR32, DIS_REG32);
35890 
35891       
35892 
35893       
35894       
35895       
35896     } 
35897     goto MATCH_finished_a; 
35898     
35899   MATCH_label_a115: (void)0; /*placeholder for label*/ 
35900     { 
35901       unsigned Eaddr = 2 + addressToPC(MATCH_p);
35902       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35903       nextPC = 7 + MATCH_p; 
35904       
35905       #line 1010 "machine/pentium/disassembler.m"
35906       
35907 
35908               sprintf (str,  "BTRod", DIS_EADDR32, DIS_REG32);
35909 
35910       
35911 
35912       
35913       
35914       
35915     } 
35916     goto MATCH_finished_a; 
35917     
35918   MATCH_label_a116: (void)0; /*placeholder for label*/ 
35919     { 
35920       unsigned Mem = 2 + addressToPC(MATCH_p);
35921       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35922       nextPC = 4 + MATCH_p; 
35923       
35924       #line 769 "machine/pentium/disassembler.m"
35925       
35926 
35927               sprintf (str,  "LFS", DIS_REG32, DIS_MEM);
35928 
35929       
35930 
35931       
35932       
35933       
35934     } 
35935     goto MATCH_finished_a; 
35936     
35937   MATCH_label_a117: (void)0; /*placeholder for label*/ 
35938     { 
35939       unsigned Mem = 2 + addressToPC(MATCH_p);
35940       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35941       nextPC = 8 + MATCH_p; 
35942       
35943       #line 769 "machine/pentium/disassembler.m"
35944       
35945 
35946               sprintf (str,  "LFS", DIS_REG32, DIS_MEM);
35947 
35948       
35949 
35950       
35951       
35952       
35953     } 
35954     goto MATCH_finished_a; 
35955     
35956   MATCH_label_a118: (void)0; /*placeholder for label*/ 
35957     { 
35958       unsigned Mem = 2 + addressToPC(MATCH_p);
35959       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35960       nextPC = 7 + MATCH_p; 
35961       
35962       #line 769 "machine/pentium/disassembler.m"
35963       
35964 
35965               sprintf (str,  "LFS", DIS_REG32, DIS_MEM);
35966 
35967       
35968 
35969       
35970       
35971       
35972     } 
35973     goto MATCH_finished_a; 
35974     
35975   MATCH_label_a119: (void)0; /*placeholder for label*/ 
35976     { 
35977       unsigned Mem = 2 + addressToPC(MATCH_p);
35978       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35979       nextPC = 4 + MATCH_p; 
35980       
35981       #line 766 "machine/pentium/disassembler.m"
35982       
35983 
35984               sprintf (str,  "LGS", DIS_REG32, DIS_MEM);
35985 
35986       
35987 
35988       
35989       
35990       
35991     } 
35992     goto MATCH_finished_a; 
35993     
35994   MATCH_label_a120: (void)0; /*placeholder for label*/ 
35995     { 
35996       unsigned Mem = 2 + addressToPC(MATCH_p);
35997       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
35998       nextPC = 8 + MATCH_p; 
35999       
36000       #line 766 "machine/pentium/disassembler.m"
36001       
36002 
36003               sprintf (str,  "LGS", DIS_REG32, DIS_MEM);
36004 
36005       
36006 
36007       
36008       
36009       
36010     } 
36011     goto MATCH_finished_a; 
36012     
36013   MATCH_label_a121: (void)0; /*placeholder for label*/ 
36014     { 
36015       unsigned Mem = 2 + addressToPC(MATCH_p);
36016       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36017       nextPC = 7 + MATCH_p; 
36018       
36019       #line 766 "machine/pentium/disassembler.m"
36020       
36021 
36022               sprintf (str,  "LGS", DIS_REG32, DIS_MEM);
36023 
36024       
36025 
36026       
36027       
36028       
36029     } 
36030     goto MATCH_finished_a; 
36031     
36032   MATCH_label_a122: (void)0; /*placeholder for label*/ 
36033     { 
36034       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36035       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36036       nextPC = 3 + MATCH_p; 
36037       
36038       #line 645 "machine/pentium/disassembler.m"
36039       
36040 
36041               sprintf (str,  "MOVZX.Gv.Ebod", DIS_R32, DIS_EADDR8);
36042 
36043       
36044 
36045       
36046       
36047       
36048     } 
36049     goto MATCH_finished_a; 
36050     
36051   MATCH_label_a123: (void)0; /*placeholder for label*/ 
36052     { 
36053       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36054       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36055       nextPC = 4 + MATCH_p; 
36056       
36057       #line 645 "machine/pentium/disassembler.m"
36058       
36059 
36060               sprintf (str,  "MOVZX.Gv.Ebod", DIS_R32, DIS_EADDR8);
36061 
36062       
36063 
36064       
36065       
36066       
36067     } 
36068     goto MATCH_finished_a; 
36069     
36070   MATCH_label_a124: (void)0; /*placeholder for label*/ 
36071     { 
36072       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36073       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36074       nextPC = 8 + MATCH_p; 
36075       
36076       #line 645 "machine/pentium/disassembler.m"
36077       
36078 
36079               sprintf (str,  "MOVZX.Gv.Ebod", DIS_R32, DIS_EADDR8);
36080 
36081       
36082 
36083       
36084       
36085       
36086     } 
36087     goto MATCH_finished_a; 
36088     
36089   MATCH_label_a125: (void)0; /*placeholder for label*/ 
36090     { 
36091       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36092       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36093       nextPC = 7 + MATCH_p; 
36094       
36095       #line 645 "machine/pentium/disassembler.m"
36096       
36097 
36098               sprintf (str,  "MOVZX.Gv.Ebod", DIS_R32, DIS_EADDR8);
36099 
36100       
36101 
36102       
36103       
36104       
36105     } 
36106     goto MATCH_finished_a; 
36107     
36108   MATCH_label_a126: (void)0; /*placeholder for label*/ 
36109     { 
36110       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36111       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36112       nextPC = 3 + MATCH_p; 
36113       
36114       #line 642 "machine/pentium/disassembler.m"
36115       
36116 
36117               sprintf (str,  "MOVZX.Gv.Ew", DIS_R32, DIS_EADDR16);
36118 
36119       
36120 
36121       
36122       
36123       
36124     } 
36125     goto MATCH_finished_a; 
36126     
36127   MATCH_label_a127: (void)0; /*placeholder for label*/ 
36128     { 
36129       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36130       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36131       nextPC = 4 + MATCH_p; 
36132       
36133       #line 642 "machine/pentium/disassembler.m"
36134       
36135 
36136               sprintf (str,  "MOVZX.Gv.Ew", DIS_R32, DIS_EADDR16);
36137 
36138       
36139 
36140       
36141       
36142       
36143     } 
36144     goto MATCH_finished_a; 
36145     
36146   MATCH_label_a128: (void)0; /*placeholder for label*/ 
36147     { 
36148       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36149       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36150       nextPC = 8 + MATCH_p; 
36151       
36152       #line 642 "machine/pentium/disassembler.m"
36153       
36154 
36155               sprintf (str,  "MOVZX.Gv.Ew", DIS_R32, DIS_EADDR16);
36156 
36157       
36158 
36159       
36160       
36161       
36162     } 
36163     goto MATCH_finished_a; 
36164     
36165   MATCH_label_a129: (void)0; /*placeholder for label*/ 
36166     { 
36167       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36168       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36169       nextPC = 7 + MATCH_p; 
36170       
36171       #line 642 "machine/pentium/disassembler.m"
36172       
36173 
36174               sprintf (str,  "MOVZX.Gv.Ew", DIS_R32, DIS_EADDR16);
36175 
36176       
36177 
36178       
36179       
36180       
36181     } 
36182     goto MATCH_finished_a; 
36183     
36184   MATCH_label_a130: (void)0; /*placeholder for label*/ 
36185     { 
36186       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36187       int /* [~128..127] */ i8 = 
36188         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
36189       nextPC = 4 + MATCH_p; 
36190       
36191       #line 1028 "machine/pentium/disassembler.m"
36192       
36193 
36194               sprintf (str,  "BTiod", DIS_EADDR32, DIS_I8);
36195 
36196       
36197 
36198       
36199       
36200       
36201     } 
36202     goto MATCH_finished_a; 
36203     
36204   MATCH_label_a131: (void)0; /*placeholder for label*/ 
36205     { 
36206       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36207       int /* [~128..127] */ i8 = 
36208         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
36209       nextPC = 5 + MATCH_p; 
36210       
36211       #line 1028 "machine/pentium/disassembler.m"
36212       
36213 
36214               sprintf (str,  "BTiod", DIS_EADDR32, DIS_I8);
36215 
36216       
36217 
36218       
36219       
36220       
36221     } 
36222     goto MATCH_finished_a; 
36223     
36224   MATCH_label_a132: (void)0; /*placeholder for label*/ 
36225     { 
36226       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36227       int /* [~128..127] */ i8 = 
36228         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
36229       nextPC = 9 + MATCH_p; 
36230       
36231       #line 1028 "machine/pentium/disassembler.m"
36232       
36233 
36234               sprintf (str,  "BTiod", DIS_EADDR32, DIS_I8);
36235 
36236       
36237 
36238       
36239       
36240       
36241     } 
36242     goto MATCH_finished_a; 
36243     
36244   MATCH_label_a133: (void)0; /*placeholder for label*/ 
36245     { 
36246       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36247       int /* [~128..127] */ i8 = 
36248         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
36249       nextPC = 8 + MATCH_p; 
36250       
36251       #line 1028 "machine/pentium/disassembler.m"
36252       
36253 
36254               sprintf (str,  "BTiod", DIS_EADDR32, DIS_I8);
36255 
36256       
36257 
36258       
36259       
36260       
36261     } 
36262     goto MATCH_finished_a; 
36263     
36264   MATCH_label_a134: (void)0; /*placeholder for label*/ 
36265     { 
36266       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36267       int /* [~128..127] */ i8 = 
36268         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
36269       nextPC = 4 + MATCH_p; 
36270       
36271       #line 992 "machine/pentium/disassembler.m"
36272       
36273 
36274               sprintf (str,  "BTSiod", DIS_I8, DIS_EADDR32);
36275 
36276       
36277 
36278       
36279       
36280       
36281     } 
36282     goto MATCH_finished_a; 
36283     
36284   MATCH_label_a135: (void)0; /*placeholder for label*/ 
36285     { 
36286       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36287       int /* [~128..127] */ i8 = 
36288         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
36289       nextPC = 5 + MATCH_p; 
36290       
36291       #line 992 "machine/pentium/disassembler.m"
36292       
36293 
36294               sprintf (str,  "BTSiod", DIS_I8, DIS_EADDR32);
36295 
36296       
36297 
36298       
36299       
36300       
36301     } 
36302     goto MATCH_finished_a; 
36303     
36304   MATCH_label_a136: (void)0; /*placeholder for label*/ 
36305     { 
36306       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36307       int /* [~128..127] */ i8 = 
36308         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
36309       nextPC = 9 + MATCH_p; 
36310       
36311       #line 992 "machine/pentium/disassembler.m"
36312       
36313 
36314               sprintf (str,  "BTSiod", DIS_I8, DIS_EADDR32);
36315 
36316       
36317 
36318       
36319       
36320       
36321     } 
36322     goto MATCH_finished_a; 
36323     
36324   MATCH_label_a137: (void)0; /*placeholder for label*/ 
36325     { 
36326       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36327       int /* [~128..127] */ i8 = 
36328         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
36329       nextPC = 8 + MATCH_p; 
36330       
36331       #line 992 "machine/pentium/disassembler.m"
36332       
36333 
36334               sprintf (str,  "BTSiod", DIS_I8, DIS_EADDR32);
36335 
36336       
36337 
36338       
36339       
36340       
36341     } 
36342     goto MATCH_finished_a; 
36343     
36344   MATCH_label_a138: (void)0; /*placeholder for label*/ 
36345     { 
36346       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36347       int /* [~128..127] */ i8 = 
36348         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
36349       nextPC = 4 + MATCH_p; 
36350       
36351       #line 1004 "machine/pentium/disassembler.m"
36352       
36353 
36354               sprintf (str,  "BTRiod", DIS_EADDR32, DIS_I8);
36355 
36356       
36357 
36358       
36359       
36360       
36361     } 
36362     goto MATCH_finished_a; 
36363     
36364   MATCH_label_a139: (void)0; /*placeholder for label*/ 
36365     { 
36366       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36367       int /* [~128..127] */ i8 = 
36368         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
36369       nextPC = 5 + MATCH_p; 
36370       
36371       #line 1004 "machine/pentium/disassembler.m"
36372       
36373 
36374               sprintf (str,  "BTRiod", DIS_EADDR32, DIS_I8);
36375 
36376       
36377 
36378       
36379       
36380       
36381     } 
36382     goto MATCH_finished_a; 
36383     
36384   MATCH_label_a140: (void)0; /*placeholder for label*/ 
36385     { 
36386       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36387       int /* [~128..127] */ i8 = 
36388         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
36389       nextPC = 9 + MATCH_p; 
36390       
36391       #line 1004 "machine/pentium/disassembler.m"
36392       
36393 
36394               sprintf (str,  "BTRiod", DIS_EADDR32, DIS_I8);
36395 
36396       
36397 
36398       
36399       
36400       
36401     } 
36402     goto MATCH_finished_a; 
36403     
36404   MATCH_label_a141: (void)0; /*placeholder for label*/ 
36405     { 
36406       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36407       int /* [~128..127] */ i8 = 
36408         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
36409       nextPC = 8 + MATCH_p; 
36410       
36411       #line 1004 "machine/pentium/disassembler.m"
36412       
36413 
36414               sprintf (str,  "BTRiod", DIS_EADDR32, DIS_I8);
36415 
36416       
36417 
36418       
36419       
36420       
36421     } 
36422     goto MATCH_finished_a; 
36423     
36424   MATCH_label_a142: (void)0; /*placeholder for label*/ 
36425     { 
36426       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36427       int /* [~128..127] */ i8 = 
36428         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
36429       nextPC = 4 + MATCH_p; 
36430       
36431       #line 1016 "machine/pentium/disassembler.m"
36432       
36433 
36434               sprintf (str,  "BTCiod", DIS_EADDR32, DIS_I8);
36435 
36436       
36437 
36438       
36439       
36440       
36441     } 
36442     goto MATCH_finished_a; 
36443     
36444   MATCH_label_a143: (void)0; /*placeholder for label*/ 
36445     { 
36446       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36447       int /* [~128..127] */ i8 = 
36448         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
36449       nextPC = 5 + MATCH_p; 
36450       
36451       #line 1016 "machine/pentium/disassembler.m"
36452       
36453 
36454               sprintf (str,  "BTCiod", DIS_EADDR32, DIS_I8);
36455 
36456       
36457 
36458       
36459       
36460       
36461     } 
36462     goto MATCH_finished_a; 
36463     
36464   MATCH_label_a144: (void)0; /*placeholder for label*/ 
36465     { 
36466       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36467       int /* [~128..127] */ i8 = 
36468         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
36469       nextPC = 9 + MATCH_p; 
36470       
36471       #line 1016 "machine/pentium/disassembler.m"
36472       
36473 
36474               sprintf (str,  "BTCiod", DIS_EADDR32, DIS_I8);
36475 
36476       
36477 
36478       
36479       
36480       
36481     } 
36482     goto MATCH_finished_a; 
36483     
36484   MATCH_label_a145: (void)0; /*placeholder for label*/ 
36485     { 
36486       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36487       int /* [~128..127] */ i8 = 
36488         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
36489       nextPC = 8 + MATCH_p; 
36490       
36491       #line 1016 "machine/pentium/disassembler.m"
36492       
36493 
36494               sprintf (str,  "BTCiod", DIS_EADDR32, DIS_I8);
36495 
36496       
36497 
36498       
36499       
36500       
36501     } 
36502     goto MATCH_finished_a; 
36503     
36504   MATCH_label_a146: (void)0; /*placeholder for label*/ 
36505     { 
36506       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36507       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36508       nextPC = 3 + MATCH_p; 
36509       
36510       #line 1022 "machine/pentium/disassembler.m"
36511       
36512 
36513               sprintf (str,  "BTCod", DIS_EADDR32, DIS_REG32);
36514 
36515       
36516 
36517       
36518       
36519       
36520     } 
36521     goto MATCH_finished_a; 
36522     
36523   MATCH_label_a147: (void)0; /*placeholder for label*/ 
36524     { 
36525       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36526       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36527       nextPC = 4 + MATCH_p; 
36528       
36529       #line 1022 "machine/pentium/disassembler.m"
36530       
36531 
36532               sprintf (str,  "BTCod", DIS_EADDR32, DIS_REG32);
36533 
36534       
36535 
36536       
36537       
36538       
36539     } 
36540     goto MATCH_finished_a; 
36541     
36542   MATCH_label_a148: (void)0; /*placeholder for label*/ 
36543     { 
36544       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36545       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36546       nextPC = 8 + MATCH_p; 
36547       
36548       #line 1022 "machine/pentium/disassembler.m"
36549       
36550 
36551               sprintf (str,  "BTCod", DIS_EADDR32, DIS_REG32);
36552 
36553       
36554 
36555       
36556       
36557       
36558     } 
36559     goto MATCH_finished_a; 
36560     
36561   MATCH_label_a149: (void)0; /*placeholder for label*/ 
36562     { 
36563       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36564       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36565       nextPC = 7 + MATCH_p; 
36566       
36567       #line 1022 "machine/pentium/disassembler.m"
36568       
36569 
36570               sprintf (str,  "BTCod", DIS_EADDR32, DIS_REG32);
36571 
36572       
36573 
36574       
36575       
36576       
36577     } 
36578     goto MATCH_finished_a; 
36579     
36580   MATCH_label_a150: (void)0; /*placeholder for label*/ 
36581     { 
36582       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36583       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36584       nextPC = 3 + MATCH_p; 
36585       
36586       #line 1049 "machine/pentium/disassembler.m"
36587       
36588 
36589               sprintf (str,  "BSFod", DIS_REG32, DIS_EADDR32);
36590 
36591       
36592 
36593       
36594       
36595       
36596     } 
36597     goto MATCH_finished_a; 
36598     
36599   MATCH_label_a151: (void)0; /*placeholder for label*/ 
36600     { 
36601       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36602       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36603       nextPC = 4 + MATCH_p; 
36604       
36605       #line 1049 "machine/pentium/disassembler.m"
36606       
36607 
36608               sprintf (str,  "BSFod", DIS_REG32, DIS_EADDR32);
36609 
36610       
36611 
36612       
36613       
36614       
36615     } 
36616     goto MATCH_finished_a; 
36617     
36618   MATCH_label_a152: (void)0; /*placeholder for label*/ 
36619     { 
36620       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36621       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36622       nextPC = 8 + MATCH_p; 
36623       
36624       #line 1049 "machine/pentium/disassembler.m"
36625       
36626 
36627               sprintf (str,  "BSFod", DIS_REG32, DIS_EADDR32);
36628 
36629       
36630 
36631       
36632       
36633       
36634     } 
36635     goto MATCH_finished_a; 
36636     
36637   MATCH_label_a153: (void)0; /*placeholder for label*/ 
36638     { 
36639       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36640       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36641       nextPC = 7 + MATCH_p; 
36642       
36643       #line 1049 "machine/pentium/disassembler.m"
36644       
36645 
36646               sprintf (str,  "BSFod", DIS_REG32, DIS_EADDR32);
36647 
36648       
36649 
36650       
36651       
36652       
36653     } 
36654     goto MATCH_finished_a; 
36655     
36656   MATCH_label_a154: (void)0; /*placeholder for label*/ 
36657     { 
36658       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36659       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36660       nextPC = 3 + MATCH_p; 
36661       
36662       #line 1043 "machine/pentium/disassembler.m"
36663       
36664 
36665               sprintf (str,  "BSRod", DIS_REG32, DIS_EADDR32);
36666 
36667       
36668 
36669       
36670       
36671       
36672     } 
36673     goto MATCH_finished_a; 
36674     
36675   MATCH_label_a155: (void)0; /*placeholder for label*/ 
36676     { 
36677       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36678       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36679       nextPC = 4 + MATCH_p; 
36680       
36681       #line 1043 "machine/pentium/disassembler.m"
36682       
36683 
36684               sprintf (str,  "BSRod", DIS_REG32, DIS_EADDR32);
36685 
36686       
36687 
36688       
36689       
36690       
36691     } 
36692     goto MATCH_finished_a; 
36693     
36694   MATCH_label_a156: (void)0; /*placeholder for label*/ 
36695     { 
36696       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36697       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36698       nextPC = 8 + MATCH_p; 
36699       
36700       #line 1043 "machine/pentium/disassembler.m"
36701       
36702 
36703               sprintf (str,  "BSRod", DIS_REG32, DIS_EADDR32);
36704 
36705       
36706 
36707       
36708       
36709       
36710     } 
36711     goto MATCH_finished_a; 
36712     
36713   MATCH_label_a157: (void)0; /*placeholder for label*/ 
36714     { 
36715       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36716       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36717       nextPC = 7 + MATCH_p; 
36718       
36719       #line 1043 "machine/pentium/disassembler.m"
36720       
36721 
36722               sprintf (str,  "BSRod", DIS_REG32, DIS_EADDR32);
36723 
36724       
36725 
36726       
36727       
36728       
36729     } 
36730     goto MATCH_finished_a; 
36731     
36732   MATCH_label_a158: (void)0; /*placeholder for label*/ 
36733     { 
36734       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36735       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36736       nextPC = 3 + MATCH_p; 
36737       
36738       #line 654 "machine/pentium/disassembler.m"
36739       
36740 
36741               sprintf (str,  "MOVSX.Gv.Ebod", DIS_R32, DIS_EADDR8);
36742 
36743       
36744 
36745       
36746       
36747       
36748     } 
36749     goto MATCH_finished_a; 
36750     
36751   MATCH_label_a159: (void)0; /*placeholder for label*/ 
36752     { 
36753       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36754       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36755       nextPC = 4 + MATCH_p; 
36756       
36757       #line 654 "machine/pentium/disassembler.m"
36758       
36759 
36760               sprintf (str,  "MOVSX.Gv.Ebod", DIS_R32, DIS_EADDR8);
36761 
36762       
36763 
36764       
36765       
36766       
36767     } 
36768     goto MATCH_finished_a; 
36769     
36770   MATCH_label_a160: (void)0; /*placeholder for label*/ 
36771     { 
36772       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36773       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36774       nextPC = 8 + MATCH_p; 
36775       
36776       #line 654 "machine/pentium/disassembler.m"
36777       
36778 
36779               sprintf (str,  "MOVSX.Gv.Ebod", DIS_R32, DIS_EADDR8);
36780 
36781       
36782 
36783       
36784       
36785       
36786     } 
36787     goto MATCH_finished_a; 
36788     
36789   MATCH_label_a161: (void)0; /*placeholder for label*/ 
36790     { 
36791       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36792       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36793       nextPC = 7 + MATCH_p; 
36794       
36795       #line 654 "machine/pentium/disassembler.m"
36796       
36797 
36798               sprintf (str,  "MOVSX.Gv.Ebod", DIS_R32, DIS_EADDR8);
36799 
36800       
36801 
36802       
36803       
36804       
36805     } 
36806     goto MATCH_finished_a; 
36807     
36808   MATCH_label_a162: (void)0; /*placeholder for label*/ 
36809     { 
36810       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36811       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36812       nextPC = 3 + MATCH_p; 
36813       
36814       #line 651 "machine/pentium/disassembler.m"
36815       
36816 
36817               sprintf (str,  "MOVSX.Gv.Ew", DIS_R32, DIS_EADDR16);
36818 
36819       
36820 
36821       
36822       
36823       
36824     } 
36825     goto MATCH_finished_a; 
36826     
36827   MATCH_label_a163: (void)0; /*placeholder for label*/ 
36828     { 
36829       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36830       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36831       nextPC = 4 + MATCH_p; 
36832       
36833       #line 651 "machine/pentium/disassembler.m"
36834       
36835 
36836               sprintf (str,  "MOVSX.Gv.Ew", DIS_R32, DIS_EADDR16);
36837 
36838       
36839 
36840       
36841       
36842       
36843     } 
36844     goto MATCH_finished_a; 
36845     
36846   MATCH_label_a164: (void)0; /*placeholder for label*/ 
36847     { 
36848       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36849       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36850       nextPC = 8 + MATCH_p; 
36851       
36852       #line 651 "machine/pentium/disassembler.m"
36853       
36854 
36855               sprintf (str,  "MOVSX.Gv.Ew", DIS_R32, DIS_EADDR16);
36856 
36857       
36858 
36859       
36860       
36861       
36862     } 
36863     goto MATCH_finished_a; 
36864     
36865   MATCH_label_a165: (void)0; /*placeholder for label*/ 
36866     { 
36867       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36868       unsigned r32 = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36869       nextPC = 7 + MATCH_p; 
36870       
36871       #line 651 "machine/pentium/disassembler.m"
36872       
36873 
36874               sprintf (str,  "MOVSX.Gv.Ew", DIS_R32, DIS_EADDR16);
36875 
36876       
36877 
36878       
36879       
36880       
36881     } 
36882     goto MATCH_finished_a; 
36883     
36884   MATCH_label_a166: (void)0; /*placeholder for label*/ 
36885     { 
36886       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36887       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36888       nextPC = 3 + MATCH_p; 
36889       
36890       #line 77 "machine/pentium/disassembler.m"
36891       
36892 
36893               sprintf (str,  "XADD.Eb.Gb", DIS_EADDR8, DIS_REG8);
36894 
36895       
36896 
36897       
36898       
36899       
36900     } 
36901     goto MATCH_finished_a; 
36902     
36903   MATCH_label_a167: (void)0; /*placeholder for label*/ 
36904     { 
36905       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36906       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36907       nextPC = 4 + MATCH_p; 
36908       
36909       #line 77 "machine/pentium/disassembler.m"
36910       
36911 
36912               sprintf (str,  "XADD.Eb.Gb", DIS_EADDR8, DIS_REG8);
36913 
36914       
36915 
36916       
36917       
36918       
36919     } 
36920     goto MATCH_finished_a; 
36921     
36922   MATCH_label_a168: (void)0; /*placeholder for label*/ 
36923     { 
36924       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36925       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36926       nextPC = 8 + MATCH_p; 
36927       
36928       #line 77 "machine/pentium/disassembler.m"
36929       
36930 
36931               sprintf (str,  "XADD.Eb.Gb", DIS_EADDR8, DIS_REG8);
36932 
36933       
36934 
36935       
36936       
36937       
36938     } 
36939     goto MATCH_finished_a; 
36940     
36941   MATCH_label_a169: (void)0; /*placeholder for label*/ 
36942     { 
36943       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36944       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36945       nextPC = 7 + MATCH_p; 
36946       
36947       #line 77 "machine/pentium/disassembler.m"
36948       
36949 
36950               sprintf (str,  "XADD.Eb.Gb", DIS_EADDR8, DIS_REG8);
36951 
36952       
36953 
36954       
36955       
36956       
36957     } 
36958     goto MATCH_finished_a; 
36959     
36960   MATCH_label_a170: (void)0; /*placeholder for label*/ 
36961     { 
36962       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36963       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36964       nextPC = 3 + MATCH_p; 
36965       
36966       #line 71 "machine/pentium/disassembler.m"
36967       
36968 
36969               sprintf (str,  "XADD.Ev.Gvod", DIS_EADDR32, DIS_REG32);
36970 
36971       
36972 
36973       
36974       
36975       
36976     } 
36977     goto MATCH_finished_a; 
36978     
36979   MATCH_label_a171: (void)0; /*placeholder for label*/ 
36980     { 
36981       unsigned Eaddr = 2 + addressToPC(MATCH_p);
36982       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
36983       nextPC = 4 + MATCH_p; 
36984       
36985       #line 71 "machine/pentium/disassembler.m"
36986       
36987 
36988               sprintf (str,  "XADD.Ev.Gvod", DIS_EADDR32, DIS_REG32);
36989 
36990       
36991 
36992       
36993       
36994       
36995     } 
36996     goto MATCH_finished_a; 
36997     
36998   MATCH_label_a172: (void)0; /*placeholder for label*/ 
36999     { 
37000       unsigned Eaddr = 2 + addressToPC(MATCH_p);
37001       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
37002       nextPC = 8 + MATCH_p; 
37003       
37004       #line 71 "machine/pentium/disassembler.m"
37005       
37006 
37007               sprintf (str,  "XADD.Ev.Gvod", DIS_EADDR32, DIS_REG32);
37008 
37009       
37010 
37011       
37012       
37013       
37014     } 
37015     goto MATCH_finished_a; 
37016     
37017   MATCH_label_a173: (void)0; /*placeholder for label*/ 
37018     { 
37019       unsigned Eaddr = 2 + addressToPC(MATCH_p);
37020       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
37021       nextPC = 7 + MATCH_p; 
37022       
37023       #line 71 "machine/pentium/disassembler.m"
37024       
37025 
37026               sprintf (str,  "XADD.Ev.Gvod", DIS_EADDR32, DIS_REG32);
37027 
37028       
37029 
37030       
37031       
37032       
37033     } 
37034     goto MATCH_finished_a; 
37035     
37036   MATCH_label_a174: (void)0; /*placeholder for label*/ 
37037     { 
37038       unsigned Mem = 2 + addressToPC(MATCH_p);
37039       nextPC = 4 + MATCH_p; 
37040       
37041       #line 938 "machine/pentium/disassembler.m"
37042       
37043 
37044               sprintf (str,  "CMPXCHG8B", DIS_MEM);
37045 
37046       
37047 
37048       
37049       
37050       
37051     } 
37052     goto MATCH_finished_a; 
37053     
37054   MATCH_label_a175: (void)0; /*placeholder for label*/ 
37055     { 
37056       unsigned Mem = 2 + addressToPC(MATCH_p);
37057       nextPC = 8 + MATCH_p; 
37058       
37059       #line 938 "machine/pentium/disassembler.m"
37060       
37061 
37062               sprintf (str,  "CMPXCHG8B", DIS_MEM);
37063 
37064       
37065 
37066       
37067       
37068       
37069     } 
37070     goto MATCH_finished_a; 
37071     
37072   MATCH_label_a176: (void)0; /*placeholder for label*/ 
37073     { 
37074       unsigned Mem = 2 + addressToPC(MATCH_p);
37075       nextPC = 7 + MATCH_p; 
37076       
37077       #line 938 "machine/pentium/disassembler.m"
37078       
37079 
37080               sprintf (str,  "CMPXCHG8B", DIS_MEM);
37081 
37082       
37083 
37084       
37085       
37086       
37087     } 
37088     goto MATCH_finished_a; 
37089     
37090   MATCH_label_a177: (void)0; /*placeholder for label*/ 
37091     { 
37092       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37093       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37094       nextPC = 2 + MATCH_p; 
37095       
37096       #line 1213 "machine/pentium/disassembler.m"
37097       
37098 
37099               sprintf (str,  "ADCmrb", DIS_EADDR8, DIS_R8);
37100 
37101       
37102 
37103       
37104       
37105       
37106     } 
37107     goto MATCH_finished_a; 
37108     
37109   MATCH_label_a178: (void)0; /*placeholder for label*/ 
37110     { 
37111       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37112       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37113       nextPC = 3 + MATCH_p; 
37114       
37115       #line 1213 "machine/pentium/disassembler.m"
37116       
37117 
37118               sprintf (str,  "ADCmrb", DIS_EADDR8, DIS_R8);
37119 
37120       
37121 
37122       
37123       
37124       
37125     } 
37126     goto MATCH_finished_a; 
37127     
37128   MATCH_label_a179: (void)0; /*placeholder for label*/ 
37129     { 
37130       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37131       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37132       nextPC = 7 + MATCH_p; 
37133       
37134       #line 1213 "machine/pentium/disassembler.m"
37135       
37136 
37137               sprintf (str,  "ADCmrb", DIS_EADDR8, DIS_R8);
37138 
37139       
37140 
37141       
37142       
37143       
37144     } 
37145     goto MATCH_finished_a; 
37146     
37147   MATCH_label_a180: (void)0; /*placeholder for label*/ 
37148     { 
37149       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37150       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37151       nextPC = 6 + MATCH_p; 
37152       
37153       #line 1213 "machine/pentium/disassembler.m"
37154       
37155 
37156               sprintf (str,  "ADCmrb", DIS_EADDR8, DIS_R8);
37157 
37158       
37159 
37160       
37161       
37162       
37163     } 
37164     goto MATCH_finished_a; 
37165     
37166   MATCH_label_a181: (void)0; /*placeholder for label*/ 
37167     { 
37168       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37169       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37170       nextPC = 2 + MATCH_p; 
37171       
37172       #line 1180 "machine/pentium/disassembler.m"
37173       
37174 
37175               sprintf (str,  "ADCmrod", DIS_EADDR32, DIS_REG32);
37176 
37177       
37178 
37179       
37180       
37181       
37182     } 
37183     goto MATCH_finished_a; 
37184     
37185   MATCH_label_a182: (void)0; /*placeholder for label*/ 
37186     { 
37187       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37188       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37189       nextPC = 3 + MATCH_p; 
37190       
37191       #line 1180 "machine/pentium/disassembler.m"
37192       
37193 
37194               sprintf (str,  "ADCmrod", DIS_EADDR32, DIS_REG32);
37195 
37196       
37197 
37198       
37199       
37200       
37201     } 
37202     goto MATCH_finished_a; 
37203     
37204   MATCH_label_a183: (void)0; /*placeholder for label*/ 
37205     { 
37206       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37207       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37208       nextPC = 7 + MATCH_p; 
37209       
37210       #line 1180 "machine/pentium/disassembler.m"
37211       
37212 
37213               sprintf (str,  "ADCmrod", DIS_EADDR32, DIS_REG32);
37214 
37215       
37216 
37217       
37218       
37219       
37220     } 
37221     goto MATCH_finished_a; 
37222     
37223   MATCH_label_a184: (void)0; /*placeholder for label*/ 
37224     { 
37225       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37226       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37227       nextPC = 6 + MATCH_p; 
37228       
37229       #line 1180 "machine/pentium/disassembler.m"
37230       
37231 
37232               sprintf (str,  "ADCmrod", DIS_EADDR32, DIS_REG32);
37233 
37234       
37235 
37236       
37237       
37238       
37239     } 
37240     goto MATCH_finished_a; 
37241     
37242   MATCH_label_a185: (void)0; /*placeholder for label*/ 
37243     { 
37244       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37245       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37246       nextPC = 2 + MATCH_p; 
37247       
37248       #line 1141 "machine/pentium/disassembler.m"
37249       
37250 
37251               sprintf (str,  "ADCrmb", DIS_R8, DIS_EADDR8);
37252 
37253       
37254 
37255       
37256       
37257       
37258     } 
37259     goto MATCH_finished_a; 
37260     
37261   MATCH_label_a186: (void)0; /*placeholder for label*/ 
37262     { 
37263       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37264       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37265       nextPC = 3 + MATCH_p; 
37266       
37267       #line 1141 "machine/pentium/disassembler.m"
37268       
37269 
37270               sprintf (str,  "ADCrmb", DIS_R8, DIS_EADDR8);
37271 
37272       
37273 
37274       
37275       
37276       
37277     } 
37278     goto MATCH_finished_a; 
37279     
37280   MATCH_label_a187: (void)0; /*placeholder for label*/ 
37281     { 
37282       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37283       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37284       nextPC = 7 + MATCH_p; 
37285       
37286       #line 1141 "machine/pentium/disassembler.m"
37287       
37288 
37289               sprintf (str,  "ADCrmb", DIS_R8, DIS_EADDR8);
37290 
37291       
37292 
37293       
37294       
37295       
37296     } 
37297     goto MATCH_finished_a; 
37298     
37299   MATCH_label_a188: (void)0; /*placeholder for label*/ 
37300     { 
37301       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37302       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37303       nextPC = 6 + MATCH_p; 
37304       
37305       #line 1141 "machine/pentium/disassembler.m"
37306       
37307 
37308               sprintf (str,  "ADCrmb", DIS_R8, DIS_EADDR8);
37309 
37310       
37311 
37312       
37313       
37314       
37315     } 
37316     goto MATCH_finished_a; 
37317     
37318   MATCH_label_a189: (void)0; /*placeholder for label*/ 
37319     { 
37320       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37321       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37322       nextPC = 2 + MATCH_p; 
37323       
37324       #line 1108 "machine/pentium/disassembler.m"
37325       
37326 
37327               sprintf (str,  "ADCrmod", DIS_REG32, DIS_EADDR32);
37328 
37329       
37330 
37331       
37332       
37333       
37334     } 
37335     goto MATCH_finished_a; 
37336     
37337   MATCH_label_a190: (void)0; /*placeholder for label*/ 
37338     { 
37339       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37340       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37341       nextPC = 3 + MATCH_p; 
37342       
37343       #line 1108 "machine/pentium/disassembler.m"
37344       
37345 
37346               sprintf (str,  "ADCrmod", DIS_REG32, DIS_EADDR32);
37347 
37348       
37349 
37350       
37351       
37352       
37353     } 
37354     goto MATCH_finished_a; 
37355     
37356   MATCH_label_a191: (void)0; /*placeholder for label*/ 
37357     { 
37358       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37359       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37360       nextPC = 7 + MATCH_p; 
37361       
37362       #line 1108 "machine/pentium/disassembler.m"
37363       
37364 
37365               sprintf (str,  "ADCrmod", DIS_REG32, DIS_EADDR32);
37366 
37367       
37368 
37369       
37370       
37371       
37372     } 
37373     goto MATCH_finished_a; 
37374     
37375   MATCH_label_a192: (void)0; /*placeholder for label*/ 
37376     { 
37377       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37378       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37379       nextPC = 6 + MATCH_p; 
37380       
37381       #line 1108 "machine/pentium/disassembler.m"
37382       
37383 
37384               sprintf (str,  "ADCrmod", DIS_REG32, DIS_EADDR32);
37385 
37386       
37387 
37388       
37389       
37390       
37391     } 
37392     goto MATCH_finished_a; 
37393     
37394   MATCH_label_a193: (void)0; /*placeholder for label*/ 
37395     { 
37396       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37397       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37398       nextPC = 2 + MATCH_p; 
37399       
37400       #line 1210 "machine/pentium/disassembler.m"
37401       
37402 
37403               sprintf (str,  "SBBmrb", DIS_EADDR8, DIS_R8);
37404 
37405       
37406 
37407       
37408       
37409       
37410     } 
37411     goto MATCH_finished_a; 
37412     
37413   MATCH_label_a194: (void)0; /*placeholder for label*/ 
37414     { 
37415       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37416       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37417       nextPC = 3 + MATCH_p; 
37418       
37419       #line 1210 "machine/pentium/disassembler.m"
37420       
37421 
37422               sprintf (str,  "SBBmrb", DIS_EADDR8, DIS_R8);
37423 
37424       
37425 
37426       
37427       
37428       
37429     } 
37430     goto MATCH_finished_a; 
37431     
37432   MATCH_label_a195: (void)0; /*placeholder for label*/ 
37433     { 
37434       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37435       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37436       nextPC = 7 + MATCH_p; 
37437       
37438       #line 1210 "machine/pentium/disassembler.m"
37439       
37440 
37441               sprintf (str,  "SBBmrb", DIS_EADDR8, DIS_R8);
37442 
37443       
37444 
37445       
37446       
37447       
37448     } 
37449     goto MATCH_finished_a; 
37450     
37451   MATCH_label_a196: (void)0; /*placeholder for label*/ 
37452     { 
37453       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37454       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37455       nextPC = 6 + MATCH_p; 
37456       
37457       #line 1210 "machine/pentium/disassembler.m"
37458       
37459 
37460               sprintf (str,  "SBBmrb", DIS_EADDR8, DIS_R8);
37461 
37462       
37463 
37464       
37465       
37466       
37467     } 
37468     goto MATCH_finished_a; 
37469     
37470   MATCH_label_a197: (void)0; /*placeholder for label*/ 
37471     { 
37472       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37473       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37474       nextPC = 2 + MATCH_p; 
37475       
37476       #line 1174 "machine/pentium/disassembler.m"
37477       
37478 
37479               sprintf (str,  "SBBmrod", DIS_EADDR32, DIS_REG32);
37480 
37481       
37482 
37483       
37484       
37485       
37486     } 
37487     goto MATCH_finished_a; 
37488     
37489   MATCH_label_a198: (void)0; /*placeholder for label*/ 
37490     { 
37491       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37492       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37493       nextPC = 3 + MATCH_p; 
37494       
37495       #line 1174 "machine/pentium/disassembler.m"
37496       
37497 
37498               sprintf (str,  "SBBmrod", DIS_EADDR32, DIS_REG32);
37499 
37500       
37501 
37502       
37503       
37504       
37505     } 
37506     goto MATCH_finished_a; 
37507     
37508   MATCH_label_a199: (void)0; /*placeholder for label*/ 
37509     { 
37510       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37511       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37512       nextPC = 7 + MATCH_p; 
37513       
37514       #line 1174 "machine/pentium/disassembler.m"
37515       
37516 
37517               sprintf (str,  "SBBmrod", DIS_EADDR32, DIS_REG32);
37518 
37519       
37520 
37521       
37522       
37523       
37524     } 
37525     goto MATCH_finished_a; 
37526     
37527   MATCH_label_a200: (void)0; /*placeholder for label*/ 
37528     { 
37529       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37530       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37531       nextPC = 6 + MATCH_p; 
37532       
37533       #line 1174 "machine/pentium/disassembler.m"
37534       
37535 
37536               sprintf (str,  "SBBmrod", DIS_EADDR32, DIS_REG32);
37537 
37538       
37539 
37540       
37541       
37542       
37543     } 
37544     goto MATCH_finished_a; 
37545     
37546   MATCH_label_a201: (void)0; /*placeholder for label*/ 
37547     { 
37548       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37549       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37550       nextPC = 2 + MATCH_p; 
37551       
37552       #line 1138 "machine/pentium/disassembler.m"
37553       
37554 
37555               sprintf (str,  "SBBrmb", DIS_R8, DIS_EADDR8);
37556 
37557       
37558 
37559       
37560       
37561       
37562     } 
37563     goto MATCH_finished_a; 
37564     
37565   MATCH_label_a202: (void)0; /*placeholder for label*/ 
37566     { 
37567       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37568       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37569       nextPC = 3 + MATCH_p; 
37570       
37571       #line 1138 "machine/pentium/disassembler.m"
37572       
37573 
37574               sprintf (str,  "SBBrmb", DIS_R8, DIS_EADDR8);
37575 
37576       
37577 
37578       
37579       
37580       
37581     } 
37582     goto MATCH_finished_a; 
37583     
37584   MATCH_label_a203: (void)0; /*placeholder for label*/ 
37585     { 
37586       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37587       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37588       nextPC = 7 + MATCH_p; 
37589       
37590       #line 1138 "machine/pentium/disassembler.m"
37591       
37592 
37593               sprintf (str,  "SBBrmb", DIS_R8, DIS_EADDR8);
37594 
37595       
37596 
37597       
37598       
37599       
37600     } 
37601     goto MATCH_finished_a; 
37602     
37603   MATCH_label_a204: (void)0; /*placeholder for label*/ 
37604     { 
37605       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37606       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37607       nextPC = 6 + MATCH_p; 
37608       
37609       #line 1138 "machine/pentium/disassembler.m"
37610       
37611 
37612               sprintf (str,  "SBBrmb", DIS_R8, DIS_EADDR8);
37613 
37614       
37615 
37616       
37617       
37618       
37619     } 
37620     goto MATCH_finished_a; 
37621     
37622   MATCH_label_a205: (void)0; /*placeholder for label*/ 
37623     { 
37624       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37625       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37626       nextPC = 2 + MATCH_p; 
37627       
37628       #line 1102 "machine/pentium/disassembler.m"
37629       
37630 
37631               sprintf (str,  "SBBrmod", DIS_REG32, DIS_EADDR32);
37632 
37633       
37634 
37635       
37636       
37637       
37638     } 
37639     goto MATCH_finished_a; 
37640     
37641   MATCH_label_a206: (void)0; /*placeholder for label*/ 
37642     { 
37643       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37644       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37645       nextPC = 3 + MATCH_p; 
37646       
37647       #line 1102 "machine/pentium/disassembler.m"
37648       
37649 
37650               sprintf (str,  "SBBrmod", DIS_REG32, DIS_EADDR32);
37651 
37652       
37653 
37654       
37655       
37656       
37657     } 
37658     goto MATCH_finished_a; 
37659     
37660   MATCH_label_a207: (void)0; /*placeholder for label*/ 
37661     { 
37662       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37663       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37664       nextPC = 7 + MATCH_p; 
37665       
37666       #line 1102 "machine/pentium/disassembler.m"
37667       
37668 
37669               sprintf (str,  "SBBrmod", DIS_REG32, DIS_EADDR32);
37670 
37671       
37672 
37673       
37674       
37675       
37676     } 
37677     goto MATCH_finished_a; 
37678     
37679   MATCH_label_a208: (void)0; /*placeholder for label*/ 
37680     { 
37681       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37682       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37683       nextPC = 6 + MATCH_p; 
37684       
37685       #line 1102 "machine/pentium/disassembler.m"
37686       
37687 
37688               sprintf (str,  "SBBrmod", DIS_REG32, DIS_EADDR32);
37689 
37690       
37691 
37692       
37693       
37694       
37695     } 
37696     goto MATCH_finished_a; 
37697     
37698   MATCH_label_a209: (void)0; /*placeholder for label*/ 
37699     { 
37700       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37701       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37702       nextPC = 2 + MATCH_p; 
37703       
37704       #line 1207 "machine/pentium/disassembler.m"
37705       
37706 
37707               sprintf (str,  "ANDmrb", DIS_EADDR8, DIS_R8);
37708 
37709       
37710 
37711       
37712       
37713       
37714     } 
37715     goto MATCH_finished_a; 
37716     
37717   MATCH_label_a210: (void)0; /*placeholder for label*/ 
37718     { 
37719       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37720       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37721       nextPC = 3 + MATCH_p; 
37722       
37723       #line 1207 "machine/pentium/disassembler.m"
37724       
37725 
37726               sprintf (str,  "ANDmrb", DIS_EADDR8, DIS_R8);
37727 
37728       
37729 
37730       
37731       
37732       
37733     } 
37734     goto MATCH_finished_a; 
37735     
37736   MATCH_label_a211: (void)0; /*placeholder for label*/ 
37737     { 
37738       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37739       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37740       nextPC = 7 + MATCH_p; 
37741       
37742       #line 1207 "machine/pentium/disassembler.m"
37743       
37744 
37745               sprintf (str,  "ANDmrb", DIS_EADDR8, DIS_R8);
37746 
37747       
37748 
37749       
37750       
37751       
37752     } 
37753     goto MATCH_finished_a; 
37754     
37755   MATCH_label_a212: (void)0; /*placeholder for label*/ 
37756     { 
37757       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37758       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37759       nextPC = 6 + MATCH_p; 
37760       
37761       #line 1207 "machine/pentium/disassembler.m"
37762       
37763 
37764               sprintf (str,  "ANDmrb", DIS_EADDR8, DIS_R8);
37765 
37766       
37767 
37768       
37769       
37770       
37771     } 
37772     goto MATCH_finished_a; 
37773     
37774   MATCH_label_a213: (void)0; /*placeholder for label*/ 
37775     { 
37776       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37777       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37778       nextPC = 2 + MATCH_p; 
37779       
37780       #line 1204 "machine/pentium/disassembler.m"
37781       
37782 
37783               sprintf (str,  "SUBmrb", DIS_EADDR8, DIS_R8);
37784 
37785       
37786 
37787       
37788       
37789       
37790     } 
37791     goto MATCH_finished_a; 
37792     
37793   MATCH_label_a214: (void)0; /*placeholder for label*/ 
37794     { 
37795       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37796       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37797       nextPC = 3 + MATCH_p; 
37798       
37799       #line 1204 "machine/pentium/disassembler.m"
37800       
37801 
37802               sprintf (str,  "SUBmrb", DIS_EADDR8, DIS_R8);
37803 
37804       
37805 
37806       
37807       
37808       
37809     } 
37810     goto MATCH_finished_a; 
37811     
37812   MATCH_label_a215: (void)0; /*placeholder for label*/ 
37813     { 
37814       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37815       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37816       nextPC = 7 + MATCH_p; 
37817       
37818       #line 1204 "machine/pentium/disassembler.m"
37819       
37820 
37821               sprintf (str,  "SUBmrb", DIS_EADDR8, DIS_R8);
37822 
37823       
37824 
37825       
37826       
37827       
37828     } 
37829     goto MATCH_finished_a; 
37830     
37831   MATCH_label_a216: (void)0; /*placeholder for label*/ 
37832     { 
37833       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37834       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37835       nextPC = 6 + MATCH_p; 
37836       
37837       #line 1204 "machine/pentium/disassembler.m"
37838       
37839 
37840               sprintf (str,  "SUBmrb", DIS_EADDR8, DIS_R8);
37841 
37842       
37843 
37844       
37845       
37846       
37847     } 
37848     goto MATCH_finished_a; 
37849     
37850   MATCH_label_a217: (void)0; /*placeholder for label*/ 
37851     { 
37852       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37853       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37854       nextPC = 2 + MATCH_p; 
37855       
37856       #line 1168 "machine/pentium/disassembler.m"
37857       
37858 
37859               sprintf (str,  "ANDmrod", DIS_EADDR32, DIS_REG32);
37860 
37861       
37862 
37863       
37864       
37865       
37866     } 
37867     goto MATCH_finished_a; 
37868     
37869   MATCH_label_a218: (void)0; /*placeholder for label*/ 
37870     { 
37871       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37872       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37873       nextPC = 3 + MATCH_p; 
37874       
37875       #line 1168 "machine/pentium/disassembler.m"
37876       
37877 
37878               sprintf (str,  "ANDmrod", DIS_EADDR32, DIS_REG32);
37879 
37880       
37881 
37882       
37883       
37884       
37885     } 
37886     goto MATCH_finished_a; 
37887     
37888   MATCH_label_a219: (void)0; /*placeholder for label*/ 
37889     { 
37890       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37891       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37892       nextPC = 7 + MATCH_p; 
37893       
37894       #line 1168 "machine/pentium/disassembler.m"
37895       
37896 
37897               sprintf (str,  "ANDmrod", DIS_EADDR32, DIS_REG32);
37898 
37899       
37900 
37901       
37902       
37903       
37904     } 
37905     goto MATCH_finished_a; 
37906     
37907   MATCH_label_a220: (void)0; /*placeholder for label*/ 
37908     { 
37909       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37910       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37911       nextPC = 6 + MATCH_p; 
37912       
37913       #line 1168 "machine/pentium/disassembler.m"
37914       
37915 
37916               sprintf (str,  "ANDmrod", DIS_EADDR32, DIS_REG32);
37917 
37918       
37919 
37920       
37921       
37922       
37923     } 
37924     goto MATCH_finished_a; 
37925     
37926   MATCH_label_a221: (void)0; /*placeholder for label*/ 
37927     { 
37928       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37929       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37930       nextPC = 2 + MATCH_p; 
37931       
37932       #line 1162 "machine/pentium/disassembler.m"
37933       
37934 
37935               sprintf (str,  "SUBmrod", DIS_EADDR32, DIS_REG32);
37936 
37937       
37938 
37939       
37940       
37941       
37942     } 
37943     goto MATCH_finished_a; 
37944     
37945   MATCH_label_a222: (void)0; /*placeholder for label*/ 
37946     { 
37947       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37948       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37949       nextPC = 3 + MATCH_p; 
37950       
37951       #line 1162 "machine/pentium/disassembler.m"
37952       
37953 
37954               sprintf (str,  "SUBmrod", DIS_EADDR32, DIS_REG32);
37955 
37956       
37957 
37958       
37959       
37960       
37961     } 
37962     goto MATCH_finished_a; 
37963     
37964   MATCH_label_a223: (void)0; /*placeholder for label*/ 
37965     { 
37966       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37967       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37968       nextPC = 7 + MATCH_p; 
37969       
37970       #line 1162 "machine/pentium/disassembler.m"
37971       
37972 
37973               sprintf (str,  "SUBmrod", DIS_EADDR32, DIS_REG32);
37974 
37975       
37976 
37977       
37978       
37979       
37980     } 
37981     goto MATCH_finished_a; 
37982     
37983   MATCH_label_a224: (void)0; /*placeholder for label*/ 
37984     { 
37985       unsigned Eaddr = 1 + addressToPC(MATCH_p);
37986       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
37987       nextPC = 6 + MATCH_p; 
37988       
37989       #line 1162 "machine/pentium/disassembler.m"
37990       
37991 
37992               sprintf (str,  "SUBmrod", DIS_EADDR32, DIS_REG32);
37993 
37994       
37995 
37996       
37997       
37998       
37999     } 
38000     goto MATCH_finished_a; 
38001     
38002   MATCH_label_a225: (void)0; /*placeholder for label*/ 
38003     { 
38004       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38005       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38006       nextPC = 2 + MATCH_p; 
38007       
38008       #line 1135 "machine/pentium/disassembler.m"
38009       
38010 
38011               sprintf (str,  "ANDrmb", DIS_R8, DIS_EADDR8);
38012 
38013       
38014 
38015       
38016       
38017       
38018     } 
38019     goto MATCH_finished_a; 
38020     
38021   MATCH_label_a226: (void)0; /*placeholder for label*/ 
38022     { 
38023       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38024       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38025       nextPC = 3 + MATCH_p; 
38026       
38027       #line 1135 "machine/pentium/disassembler.m"
38028       
38029 
38030               sprintf (str,  "ANDrmb", DIS_R8, DIS_EADDR8);
38031 
38032       
38033 
38034       
38035       
38036       
38037     } 
38038     goto MATCH_finished_a; 
38039     
38040   MATCH_label_a227: (void)0; /*placeholder for label*/ 
38041     { 
38042       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38043       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38044       nextPC = 7 + MATCH_p; 
38045       
38046       #line 1135 "machine/pentium/disassembler.m"
38047       
38048 
38049               sprintf (str,  "ANDrmb", DIS_R8, DIS_EADDR8);
38050 
38051       
38052 
38053       
38054       
38055       
38056     } 
38057     goto MATCH_finished_a; 
38058     
38059   MATCH_label_a228: (void)0; /*placeholder for label*/ 
38060     { 
38061       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38062       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38063       nextPC = 6 + MATCH_p; 
38064       
38065       #line 1135 "machine/pentium/disassembler.m"
38066       
38067 
38068               sprintf (str,  "ANDrmb", DIS_R8, DIS_EADDR8);
38069 
38070       
38071 
38072       
38073       
38074       
38075     } 
38076     goto MATCH_finished_a; 
38077     
38078   MATCH_label_a229: (void)0; /*placeholder for label*/ 
38079     { 
38080       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38081       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38082       nextPC = 2 + MATCH_p; 
38083       
38084       #line 1132 "machine/pentium/disassembler.m"
38085       
38086 
38087               sprintf (str,  "SUBrmb", DIS_R8, DIS_EADDR8);
38088 
38089       
38090 
38091       
38092       
38093       
38094     } 
38095     goto MATCH_finished_a; 
38096     
38097   MATCH_label_a230: (void)0; /*placeholder for label*/ 
38098     { 
38099       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38100       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38101       nextPC = 3 + MATCH_p; 
38102       
38103       #line 1132 "machine/pentium/disassembler.m"
38104       
38105 
38106               sprintf (str,  "SUBrmb", DIS_R8, DIS_EADDR8);
38107 
38108       
38109 
38110       
38111       
38112       
38113     } 
38114     goto MATCH_finished_a; 
38115     
38116   MATCH_label_a231: (void)0; /*placeholder for label*/ 
38117     { 
38118       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38119       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38120       nextPC = 7 + MATCH_p; 
38121       
38122       #line 1132 "machine/pentium/disassembler.m"
38123       
38124 
38125               sprintf (str,  "SUBrmb", DIS_R8, DIS_EADDR8);
38126 
38127       
38128 
38129       
38130       
38131       
38132     } 
38133     goto MATCH_finished_a; 
38134     
38135   MATCH_label_a232: (void)0; /*placeholder for label*/ 
38136     { 
38137       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38138       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38139       nextPC = 6 + MATCH_p; 
38140       
38141       #line 1132 "machine/pentium/disassembler.m"
38142       
38143 
38144               sprintf (str,  "SUBrmb", DIS_R8, DIS_EADDR8);
38145 
38146       
38147 
38148       
38149       
38150       
38151     } 
38152     goto MATCH_finished_a; 
38153     
38154   MATCH_label_a233: (void)0; /*placeholder for label*/ 
38155     { 
38156       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38157       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38158       nextPC = 2 + MATCH_p; 
38159       
38160       #line 1096 "machine/pentium/disassembler.m"
38161       
38162 
38163               sprintf (str,  "ANDrmod", DIS_REG32, DIS_EADDR32);
38164 
38165       
38166 
38167       
38168       
38169       
38170     } 
38171     goto MATCH_finished_a; 
38172     
38173   MATCH_label_a234: (void)0; /*placeholder for label*/ 
38174     { 
38175       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38176       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38177       nextPC = 3 + MATCH_p; 
38178       
38179       #line 1096 "machine/pentium/disassembler.m"
38180       
38181 
38182               sprintf (str,  "ANDrmod", DIS_REG32, DIS_EADDR32);
38183 
38184       
38185 
38186       
38187       
38188       
38189     } 
38190     goto MATCH_finished_a; 
38191     
38192   MATCH_label_a235: (void)0; /*placeholder for label*/ 
38193     { 
38194       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38195       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38196       nextPC = 7 + MATCH_p; 
38197       
38198       #line 1096 "machine/pentium/disassembler.m"
38199       
38200 
38201               sprintf (str,  "ANDrmod", DIS_REG32, DIS_EADDR32);
38202 
38203       
38204 
38205       
38206       
38207       
38208     } 
38209     goto MATCH_finished_a; 
38210     
38211   MATCH_label_a236: (void)0; /*placeholder for label*/ 
38212     { 
38213       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38214       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38215       nextPC = 6 + MATCH_p; 
38216       
38217       #line 1096 "machine/pentium/disassembler.m"
38218       
38219 
38220               sprintf (str,  "ANDrmod", DIS_REG32, DIS_EADDR32);
38221 
38222       
38223 
38224       
38225       
38226       
38227     } 
38228     goto MATCH_finished_a; 
38229     
38230   MATCH_label_a237: (void)0; /*placeholder for label*/ 
38231     { 
38232       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38233       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38234       nextPC = 2 + MATCH_p; 
38235       
38236       #line 1090 "machine/pentium/disassembler.m"
38237       
38238 
38239               sprintf (str,  "SUBrmod", DIS_REG32, DIS_EADDR32);
38240 
38241       
38242 
38243       
38244       
38245       
38246     } 
38247     goto MATCH_finished_a; 
38248     
38249   MATCH_label_a238: (void)0; /*placeholder for label*/ 
38250     { 
38251       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38252       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38253       nextPC = 3 + MATCH_p; 
38254       
38255       #line 1090 "machine/pentium/disassembler.m"
38256       
38257 
38258               sprintf (str,  "SUBrmod", DIS_REG32, DIS_EADDR32);
38259 
38260       
38261 
38262       
38263       
38264       
38265     } 
38266     goto MATCH_finished_a; 
38267     
38268   MATCH_label_a239: (void)0; /*placeholder for label*/ 
38269     { 
38270       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38271       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38272       nextPC = 7 + MATCH_p; 
38273       
38274       #line 1090 "machine/pentium/disassembler.m"
38275       
38276 
38277               sprintf (str,  "SUBrmod", DIS_REG32, DIS_EADDR32);
38278 
38279       
38280 
38281       
38282       
38283       
38284     } 
38285     goto MATCH_finished_a; 
38286     
38287   MATCH_label_a240: (void)0; /*placeholder for label*/ 
38288     { 
38289       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38290       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38291       nextPC = 6 + MATCH_p; 
38292       
38293       #line 1090 "machine/pentium/disassembler.m"
38294       
38295 
38296               sprintf (str,  "SUBrmod", DIS_REG32, DIS_EADDR32);
38297 
38298       
38299 
38300       
38301       
38302       
38303     } 
38304     goto MATCH_finished_a; 
38305     
38306   MATCH_label_a241: (void)0; /*placeholder for label*/ 
38307     { 
38308       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38309       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38310       nextPC = 2 + MATCH_p; 
38311       
38312       #line 1201 "machine/pentium/disassembler.m"
38313       
38314 
38315               sprintf (str,  "XORmrb", DIS_EADDR8, DIS_R8);
38316 
38317       
38318 
38319       
38320       
38321       
38322     } 
38323     goto MATCH_finished_a; 
38324     
38325   MATCH_label_a242: (void)0; /*placeholder for label*/ 
38326     { 
38327       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38328       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38329       nextPC = 3 + MATCH_p; 
38330       
38331       #line 1201 "machine/pentium/disassembler.m"
38332       
38333 
38334               sprintf (str,  "XORmrb", DIS_EADDR8, DIS_R8);
38335 
38336       
38337 
38338       
38339       
38340       
38341     } 
38342     goto MATCH_finished_a; 
38343     
38344   MATCH_label_a243: (void)0; /*placeholder for label*/ 
38345     { 
38346       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38347       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38348       nextPC = 7 + MATCH_p; 
38349       
38350       #line 1201 "machine/pentium/disassembler.m"
38351       
38352 
38353               sprintf (str,  "XORmrb", DIS_EADDR8, DIS_R8);
38354 
38355       
38356 
38357       
38358       
38359       
38360     } 
38361     goto MATCH_finished_a; 
38362     
38363   MATCH_label_a244: (void)0; /*placeholder for label*/ 
38364     { 
38365       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38366       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38367       nextPC = 6 + MATCH_p; 
38368       
38369       #line 1201 "machine/pentium/disassembler.m"
38370       
38371 
38372               sprintf (str,  "XORmrb", DIS_EADDR8, DIS_R8);
38373 
38374       
38375 
38376       
38377       
38378       
38379     } 
38380     goto MATCH_finished_a; 
38381     
38382   MATCH_label_a245: (void)0; /*placeholder for label*/ 
38383     { 
38384       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38385       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38386       nextPC = 2 + MATCH_p; 
38387       
38388       #line 1198 "machine/pentium/disassembler.m"
38389       
38390 
38391               sprintf (str,  "CMPmrb", DIS_EADDR8, DIS_R8);
38392 
38393       
38394 
38395       
38396       
38397       
38398     } 
38399     goto MATCH_finished_a; 
38400     
38401   MATCH_label_a246: (void)0; /*placeholder for label*/ 
38402     { 
38403       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38404       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38405       nextPC = 3 + MATCH_p; 
38406       
38407       #line 1198 "machine/pentium/disassembler.m"
38408       
38409 
38410               sprintf (str,  "CMPmrb", DIS_EADDR8, DIS_R8);
38411 
38412       
38413 
38414       
38415       
38416       
38417     } 
38418     goto MATCH_finished_a; 
38419     
38420   MATCH_label_a247: (void)0; /*placeholder for label*/ 
38421     { 
38422       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38423       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38424       nextPC = 7 + MATCH_p; 
38425       
38426       #line 1198 "machine/pentium/disassembler.m"
38427       
38428 
38429               sprintf (str,  "CMPmrb", DIS_EADDR8, DIS_R8);
38430 
38431       
38432 
38433       
38434       
38435       
38436     } 
38437     goto MATCH_finished_a; 
38438     
38439   MATCH_label_a248: (void)0; /*placeholder for label*/ 
38440     { 
38441       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38442       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38443       nextPC = 6 + MATCH_p; 
38444       
38445       #line 1198 "machine/pentium/disassembler.m"
38446       
38447 
38448               sprintf (str,  "CMPmrb", DIS_EADDR8, DIS_R8);
38449 
38450       
38451 
38452       
38453       
38454       
38455     } 
38456     goto MATCH_finished_a; 
38457     
38458   MATCH_label_a249: (void)0; /*placeholder for label*/ 
38459     { 
38460       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38461       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38462       nextPC = 2 + MATCH_p; 
38463       
38464       #line 1156 "machine/pentium/disassembler.m"
38465       
38466 
38467               sprintf (str,  "XORmrod", DIS_EADDR32, DIS_REG32);
38468 
38469       
38470 
38471       
38472       
38473       
38474     } 
38475     goto MATCH_finished_a; 
38476     
38477   MATCH_label_a250: (void)0; /*placeholder for label*/ 
38478     { 
38479       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38480       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38481       nextPC = 3 + MATCH_p; 
38482       
38483       #line 1156 "machine/pentium/disassembler.m"
38484       
38485 
38486               sprintf (str,  "XORmrod", DIS_EADDR32, DIS_REG32);
38487 
38488       
38489 
38490       
38491       
38492       
38493     } 
38494     goto MATCH_finished_a; 
38495     
38496   MATCH_label_a251: (void)0; /*placeholder for label*/ 
38497     { 
38498       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38499       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38500       nextPC = 7 + MATCH_p; 
38501       
38502       #line 1156 "machine/pentium/disassembler.m"
38503       
38504 
38505               sprintf (str,  "XORmrod", DIS_EADDR32, DIS_REG32);
38506 
38507       
38508 
38509       
38510       
38511       
38512     } 
38513     goto MATCH_finished_a; 
38514     
38515   MATCH_label_a252: (void)0; /*placeholder for label*/ 
38516     { 
38517       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38518       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38519       nextPC = 6 + MATCH_p; 
38520       
38521       #line 1156 "machine/pentium/disassembler.m"
38522       
38523 
38524               sprintf (str,  "XORmrod", DIS_EADDR32, DIS_REG32);
38525 
38526       
38527 
38528       
38529       
38530       
38531     } 
38532     goto MATCH_finished_a; 
38533     
38534   MATCH_label_a253: (void)0; /*placeholder for label*/ 
38535     { 
38536       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38537       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38538       nextPC = 2 + MATCH_p; 
38539       
38540       #line 1150 "machine/pentium/disassembler.m"
38541       
38542 
38543               sprintf (str,  "CMPmrod", DIS_EADDR32, DIS_REG32);
38544 
38545       
38546 
38547       
38548       
38549       
38550     } 
38551     goto MATCH_finished_a; 
38552     
38553   MATCH_label_a254: (void)0; /*placeholder for label*/ 
38554     { 
38555       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38556       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38557       nextPC = 3 + MATCH_p; 
38558       
38559       #line 1150 "machine/pentium/disassembler.m"
38560       
38561 
38562               sprintf (str,  "CMPmrod", DIS_EADDR32, DIS_REG32);
38563 
38564       
38565 
38566       
38567       
38568       
38569     } 
38570     goto MATCH_finished_a; 
38571     
38572   MATCH_label_a255: (void)0; /*placeholder for label*/ 
38573     { 
38574       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38575       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38576       nextPC = 7 + MATCH_p; 
38577       
38578       #line 1150 "machine/pentium/disassembler.m"
38579       
38580 
38581               sprintf (str,  "CMPmrod", DIS_EADDR32, DIS_REG32);
38582 
38583       
38584 
38585       
38586       
38587       
38588     } 
38589     goto MATCH_finished_a; 
38590     
38591   MATCH_label_a256: (void)0; /*placeholder for label*/ 
38592     { 
38593       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38594       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38595       nextPC = 6 + MATCH_p; 
38596       
38597       #line 1150 "machine/pentium/disassembler.m"
38598       
38599 
38600               sprintf (str,  "CMPmrod", DIS_EADDR32, DIS_REG32);
38601 
38602       
38603 
38604       
38605       
38606       
38607     } 
38608     goto MATCH_finished_a; 
38609     
38610   MATCH_label_a257: (void)0; /*placeholder for label*/ 
38611     { 
38612       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38613       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38614       nextPC = 2 + MATCH_p; 
38615       
38616       #line 1129 "machine/pentium/disassembler.m"
38617       
38618 
38619               sprintf (str,  "XORrmb", DIS_R8, DIS_EADDR8);
38620 
38621       
38622 
38623       
38624       
38625       
38626     } 
38627     goto MATCH_finished_a; 
38628     
38629   MATCH_label_a258: (void)0; /*placeholder for label*/ 
38630     { 
38631       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38632       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38633       nextPC = 3 + MATCH_p; 
38634       
38635       #line 1129 "machine/pentium/disassembler.m"
38636       
38637 
38638               sprintf (str,  "XORrmb", DIS_R8, DIS_EADDR8);
38639 
38640       
38641 
38642       
38643       
38644       
38645     } 
38646     goto MATCH_finished_a; 
38647     
38648   MATCH_label_a259: (void)0; /*placeholder for label*/ 
38649     { 
38650       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38651       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38652       nextPC = 7 + MATCH_p; 
38653       
38654       #line 1129 "machine/pentium/disassembler.m"
38655       
38656 
38657               sprintf (str,  "XORrmb", DIS_R8, DIS_EADDR8);
38658 
38659       
38660 
38661       
38662       
38663       
38664     } 
38665     goto MATCH_finished_a; 
38666     
38667   MATCH_label_a260: (void)0; /*placeholder for label*/ 
38668     { 
38669       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38670       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38671       nextPC = 6 + MATCH_p; 
38672       
38673       #line 1129 "machine/pentium/disassembler.m"
38674       
38675 
38676               sprintf (str,  "XORrmb", DIS_R8, DIS_EADDR8);
38677 
38678       
38679 
38680       
38681       
38682       
38683     } 
38684     goto MATCH_finished_a; 
38685     
38686   MATCH_label_a261: (void)0; /*placeholder for label*/ 
38687     { 
38688       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38689       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38690       nextPC = 2 + MATCH_p; 
38691       
38692       #line 1126 "machine/pentium/disassembler.m"
38693       
38694 
38695               sprintf (str,  "CMPrmb", DIS_R8, DIS_EADDR8);
38696 
38697       
38698 
38699       
38700       
38701       
38702     } 
38703     goto MATCH_finished_a; 
38704     
38705   MATCH_label_a262: (void)0; /*placeholder for label*/ 
38706     { 
38707       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38708       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38709       nextPC = 3 + MATCH_p; 
38710       
38711       #line 1126 "machine/pentium/disassembler.m"
38712       
38713 
38714               sprintf (str,  "CMPrmb", DIS_R8, DIS_EADDR8);
38715 
38716       
38717 
38718       
38719       
38720       
38721     } 
38722     goto MATCH_finished_a; 
38723     
38724   MATCH_label_a263: (void)0; /*placeholder for label*/ 
38725     { 
38726       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38727       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38728       nextPC = 7 + MATCH_p; 
38729       
38730       #line 1126 "machine/pentium/disassembler.m"
38731       
38732 
38733               sprintf (str,  "CMPrmb", DIS_R8, DIS_EADDR8);
38734 
38735       
38736 
38737       
38738       
38739       
38740     } 
38741     goto MATCH_finished_a; 
38742     
38743   MATCH_label_a264: (void)0; /*placeholder for label*/ 
38744     { 
38745       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38746       unsigned r8 = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38747       nextPC = 6 + MATCH_p; 
38748       
38749       #line 1126 "machine/pentium/disassembler.m"
38750       
38751 
38752               sprintf (str,  "CMPrmb", DIS_R8, DIS_EADDR8);
38753 
38754       
38755 
38756       
38757       
38758       
38759     } 
38760     goto MATCH_finished_a; 
38761     
38762   MATCH_label_a265: (void)0; /*placeholder for label*/ 
38763     { 
38764       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38765       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38766       nextPC = 2 + MATCH_p; 
38767       
38768       #line 1084 "machine/pentium/disassembler.m"
38769       
38770 
38771               sprintf (str,  "XORrmod", DIS_REG32, DIS_EADDR32);
38772 
38773       
38774 
38775       
38776       
38777       
38778     } 
38779     goto MATCH_finished_a; 
38780     
38781   MATCH_label_a266: (void)0; /*placeholder for label*/ 
38782     { 
38783       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38784       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38785       nextPC = 3 + MATCH_p; 
38786       
38787       #line 1084 "machine/pentium/disassembler.m"
38788       
38789 
38790               sprintf (str,  "XORrmod", DIS_REG32, DIS_EADDR32);
38791 
38792       
38793 
38794       
38795       
38796       
38797     } 
38798     goto MATCH_finished_a; 
38799     
38800   MATCH_label_a267: (void)0; /*placeholder for label*/ 
38801     { 
38802       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38803       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38804       nextPC = 7 + MATCH_p; 
38805       
38806       #line 1084 "machine/pentium/disassembler.m"
38807       
38808 
38809               sprintf (str,  "XORrmod", DIS_REG32, DIS_EADDR32);
38810 
38811       
38812 
38813       
38814       
38815       
38816     } 
38817     goto MATCH_finished_a; 
38818     
38819   MATCH_label_a268: (void)0; /*placeholder for label*/ 
38820     { 
38821       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38822       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38823       nextPC = 6 + MATCH_p; 
38824       
38825       #line 1084 "machine/pentium/disassembler.m"
38826       
38827 
38828               sprintf (str,  "XORrmod", DIS_REG32, DIS_EADDR32);
38829 
38830       
38831 
38832       
38833       
38834       
38835     } 
38836     goto MATCH_finished_a; 
38837     
38838   MATCH_label_a269: (void)0; /*placeholder for label*/ 
38839     { 
38840       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38841       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38842       nextPC = 2 + MATCH_p; 
38843       
38844       #line 1078 "machine/pentium/disassembler.m"
38845       
38846 
38847               sprintf (str,  "CMPrmod", DIS_REG32, DIS_EADDR32);
38848 
38849       
38850 
38851       
38852       
38853       
38854     } 
38855     goto MATCH_finished_a; 
38856     
38857   MATCH_label_a270: (void)0; /*placeholder for label*/ 
38858     { 
38859       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38860       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38861       nextPC = 3 + MATCH_p; 
38862       
38863       #line 1078 "machine/pentium/disassembler.m"
38864       
38865 
38866               sprintf (str,  "CMPrmod", DIS_REG32, DIS_EADDR32);
38867 
38868       
38869 
38870       
38871       
38872       
38873     } 
38874     goto MATCH_finished_a; 
38875     
38876   MATCH_label_a271: (void)0; /*placeholder for label*/ 
38877     { 
38878       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38879       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38880       nextPC = 7 + MATCH_p; 
38881       
38882       #line 1078 "machine/pentium/disassembler.m"
38883       
38884 
38885               sprintf (str,  "CMPrmod", DIS_REG32, DIS_EADDR32);
38886 
38887       
38888 
38889       
38890       
38891       
38892     } 
38893     goto MATCH_finished_a; 
38894     
38895   MATCH_label_a272: (void)0; /*placeholder for label*/ 
38896     { 
38897       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38898       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38899       nextPC = 6 + MATCH_p; 
38900       
38901       #line 1078 "machine/pentium/disassembler.m"
38902       
38903 
38904               sprintf (str,  "CMPrmod", DIS_REG32, DIS_EADDR32);
38905 
38906       
38907 
38908       
38909       
38910       
38911     } 
38912     goto MATCH_finished_a; 
38913     
38914   MATCH_label_a273: (void)0; /*placeholder for label*/ 
38915     { 
38916       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38917       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
38918       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38919       nextPC = 6 + MATCH_p; 
38920       
38921       #line 857 "machine/pentium/disassembler.m"
38922       
38923 
38924               sprintf (str,  "IMUL.Ivd", DIS_REG32, DIS_EADDR32, DIS_I32);
38925 
38926       
38927 
38928       
38929       
38930       
38931     } 
38932     goto MATCH_finished_a; 
38933     
38934   MATCH_label_a274: (void)0; /*placeholder for label*/ 
38935     { 
38936       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38937       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
38938       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38939       nextPC = 7 + MATCH_p; 
38940       
38941       #line 857 "machine/pentium/disassembler.m"
38942       
38943 
38944               sprintf (str,  "IMUL.Ivd", DIS_REG32, DIS_EADDR32, DIS_I32);
38945 
38946       
38947 
38948       
38949       
38950       
38951     } 
38952     goto MATCH_finished_a; 
38953     
38954   MATCH_label_a275: (void)0; /*placeholder for label*/ 
38955     { 
38956       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38957       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
38958       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38959       nextPC = 11 + MATCH_p; 
38960       
38961       #line 857 "machine/pentium/disassembler.m"
38962       
38963 
38964               sprintf (str,  "IMUL.Ivd", DIS_REG32, DIS_EADDR32, DIS_I32);
38965 
38966       
38967 
38968       
38969       
38970       
38971     } 
38972     goto MATCH_finished_a; 
38973     
38974   MATCH_label_a276: (void)0; /*placeholder for label*/ 
38975     { 
38976       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38977       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
38978       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
38979       nextPC = 10 + MATCH_p; 
38980       
38981       #line 857 "machine/pentium/disassembler.m"
38982       
38983 
38984               sprintf (str,  "IMUL.Ivd", DIS_REG32, DIS_EADDR32, DIS_I32);
38985 
38986       
38987 
38988       
38989       
38990       
38991     } 
38992     goto MATCH_finished_a; 
38993     
38994   MATCH_label_a277: (void)0; /*placeholder for label*/ 
38995     { 
38996       unsigned Eaddr = 1 + addressToPC(MATCH_p);
38997       int /* [~128..127] */ i8 = 
38998         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
38999       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
39000       nextPC = 3 + MATCH_p; 
39001       
39002       #line 863 "machine/pentium/disassembler.m"
39003       
39004 
39005               sprintf (str,  "IMUL.Ibod", DIS_REG32, DIS_EADDR32, DIS_I8);
39006 
39007       
39008 
39009       
39010       
39011       
39012     } 
39013     goto MATCH_finished_a; 
39014     
39015   MATCH_label_a278: (void)0; /*placeholder for label*/ 
39016     { 
39017       unsigned Eaddr = 1 + addressToPC(MATCH_p);
39018       int /* [~128..127] */ i8 = 
39019         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
39020       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
39021       nextPC = 4 + MATCH_p; 
39022       
39023       #line 863 "machine/pentium/disassembler.m"
39024       
39025 
39026               sprintf (str,  "IMUL.Ibod", DIS_REG32, DIS_EADDR32, DIS_I8);
39027 
39028       
39029 
39030       
39031       
39032       
39033     } 
39034     goto MATCH_finished_a; 
39035     
39036   MATCH_label_a279: (void)0; /*placeholder for label*/ 
39037     { 
39038       unsigned Eaddr = 1 + addressToPC(MATCH_p);
39039       int /* [~128..127] */ i8 = 
39040         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
39041       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
39042       nextPC = 8 + MATCH_p; 
39043       
39044       #line 863 "machine/pentium/disassembler.m"
39045       
39046 
39047               sprintf (str,  "IMUL.Ibod", DIS_REG32, DIS_EADDR32, DIS_I8);
39048 
39049       
39050 
39051       
39052       
39053       
39054     } 
39055     goto MATCH_finished_a; 
39056     
39057   MATCH_label_a280: (void)0; /*placeholder for label*/ 
39058     { 
39059       unsigned Eaddr = 1 + addressToPC(MATCH_p);
39060       int /* [~128..127] */ i8 = 
39061         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
39062       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
39063       nextPC = 7 + MATCH_p; 
39064       
39065       #line 863 "machine/pentium/disassembler.m"
39066       
39067 
39068               sprintf (str,  "IMUL.Ibod", DIS_REG32, DIS_EADDR32, DIS_I8);
39069 
39070       
39071 
39072       
39073       
39074       
39075     } 
39076     goto MATCH_finished_a; 
39077     
39078   MATCH_label_a281: (void)0; /*placeholder for label*/ 
39079     { 
39080       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39081       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39082       nextPC = 3 + MATCH_p; 
39083       
39084       #line 1195 "machine/pentium/disassembler.m"
39085       
39086 
39087               sprintf (str,  "ADDmrow", DIS_EADDR16, DIS_REG16);
39088 
39089       
39090 
39091       
39092       
39093       
39094     } 
39095     goto MATCH_finished_a; 
39096     
39097   MATCH_label_a282: (void)0; /*placeholder for label*/ 
39098     { 
39099       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39100       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39101       nextPC = 4 + MATCH_p; 
39102       
39103       #line 1195 "machine/pentium/disassembler.m"
39104       
39105 
39106               sprintf (str,  "ADDmrow", DIS_EADDR16, DIS_REG16);
39107 
39108       
39109 
39110       
39111       
39112       
39113     } 
39114     goto MATCH_finished_a; 
39115     
39116   MATCH_label_a283: (void)0; /*placeholder for label*/ 
39117     { 
39118       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39119       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39120       nextPC = 8 + MATCH_p; 
39121       
39122       #line 1195 "machine/pentium/disassembler.m"
39123       
39124 
39125               sprintf (str,  "ADDmrow", DIS_EADDR16, DIS_REG16);
39126 
39127       
39128 
39129       
39130       
39131       
39132     } 
39133     goto MATCH_finished_a; 
39134     
39135   MATCH_label_a284: (void)0; /*placeholder for label*/ 
39136     { 
39137       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39138       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39139       nextPC = 7 + MATCH_p; 
39140       
39141       #line 1195 "machine/pentium/disassembler.m"
39142       
39143 
39144               sprintf (str,  "ADDmrow", DIS_EADDR16, DIS_REG16);
39145 
39146       
39147 
39148       
39149       
39150       
39151     } 
39152     goto MATCH_finished_a; 
39153     
39154   MATCH_label_a285: (void)0; /*placeholder for label*/ 
39155     { 
39156       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39157       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39158       nextPC = 3 + MATCH_p; 
39159       
39160       #line 1189 "machine/pentium/disassembler.m"
39161       
39162 
39163               sprintf (str,  "ORmrow", DIS_EADDR16, DIS_REG16);
39164 
39165       
39166 
39167       
39168       
39169       
39170     } 
39171     goto MATCH_finished_a; 
39172     
39173   MATCH_label_a286: (void)0; /*placeholder for label*/ 
39174     { 
39175       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39176       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39177       nextPC = 4 + MATCH_p; 
39178       
39179       #line 1189 "machine/pentium/disassembler.m"
39180       
39181 
39182               sprintf (str,  "ORmrow", DIS_EADDR16, DIS_REG16);
39183 
39184       
39185 
39186       
39187       
39188       
39189     } 
39190     goto MATCH_finished_a; 
39191     
39192   MATCH_label_a287: (void)0; /*placeholder for label*/ 
39193     { 
39194       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39195       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39196       nextPC = 8 + MATCH_p; 
39197       
39198       #line 1189 "machine/pentium/disassembler.m"
39199       
39200 
39201               sprintf (str,  "ORmrow", DIS_EADDR16, DIS_REG16);
39202 
39203       
39204 
39205       
39206       
39207       
39208     } 
39209     goto MATCH_finished_a; 
39210     
39211   MATCH_label_a288: (void)0; /*placeholder for label*/ 
39212     { 
39213       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39214       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39215       nextPC = 7 + MATCH_p; 
39216       
39217       #line 1189 "machine/pentium/disassembler.m"
39218       
39219 
39220               sprintf (str,  "ORmrow", DIS_EADDR16, DIS_REG16);
39221 
39222       
39223 
39224       
39225       
39226       
39227     } 
39228     goto MATCH_finished_a; 
39229     
39230   MATCH_label_a289: (void)0; /*placeholder for label*/ 
39231     { 
39232       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39233       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39234       nextPC = 3 + MATCH_p; 
39235       
39236       #line 1123 "machine/pentium/disassembler.m"
39237       
39238 
39239               sprintf (str,  "ADDrmow", DIS_REG16, DIS_EADDR16);
39240 
39241       
39242 
39243       
39244       
39245       
39246     } 
39247     goto MATCH_finished_a; 
39248     
39249   MATCH_label_a290: (void)0; /*placeholder for label*/ 
39250     { 
39251       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39252       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39253       nextPC = 4 + MATCH_p; 
39254       
39255       #line 1123 "machine/pentium/disassembler.m"
39256       
39257 
39258               sprintf (str,  "ADDrmow", DIS_REG16, DIS_EADDR16);
39259 
39260       
39261 
39262       
39263       
39264       
39265     } 
39266     goto MATCH_finished_a; 
39267     
39268   MATCH_label_a291: (void)0; /*placeholder for label*/ 
39269     { 
39270       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39271       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39272       nextPC = 8 + MATCH_p; 
39273       
39274       #line 1123 "machine/pentium/disassembler.m"
39275       
39276 
39277               sprintf (str,  "ADDrmow", DIS_REG16, DIS_EADDR16);
39278 
39279       
39280 
39281       
39282       
39283       
39284     } 
39285     goto MATCH_finished_a; 
39286     
39287   MATCH_label_a292: (void)0; /*placeholder for label*/ 
39288     { 
39289       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39290       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39291       nextPC = 7 + MATCH_p; 
39292       
39293       #line 1123 "machine/pentium/disassembler.m"
39294       
39295 
39296               sprintf (str,  "ADDrmow", DIS_REG16, DIS_EADDR16);
39297 
39298       
39299 
39300       
39301       
39302       
39303     } 
39304     goto MATCH_finished_a; 
39305     
39306   MATCH_label_a293: (void)0; /*placeholder for label*/ 
39307     { 
39308       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39309       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39310       nextPC = 3 + MATCH_p; 
39311       
39312       #line 1117 "machine/pentium/disassembler.m"
39313       
39314 
39315               sprintf (str,  "ORrmow", DIS_REG16, DIS_EADDR16);
39316 
39317       
39318 
39319       
39320       
39321       
39322     } 
39323     goto MATCH_finished_a; 
39324     
39325   MATCH_label_a294: (void)0; /*placeholder for label*/ 
39326     { 
39327       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39328       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39329       nextPC = 4 + MATCH_p; 
39330       
39331       #line 1117 "machine/pentium/disassembler.m"
39332       
39333 
39334               sprintf (str,  "ORrmow", DIS_REG16, DIS_EADDR16);
39335 
39336       
39337 
39338       
39339       
39340       
39341     } 
39342     goto MATCH_finished_a; 
39343     
39344   MATCH_label_a295: (void)0; /*placeholder for label*/ 
39345     { 
39346       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39347       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39348       nextPC = 8 + MATCH_p; 
39349       
39350       #line 1117 "machine/pentium/disassembler.m"
39351       
39352 
39353               sprintf (str,  "ORrmow", DIS_REG16, DIS_EADDR16);
39354 
39355       
39356 
39357       
39358       
39359       
39360     } 
39361     goto MATCH_finished_a; 
39362     
39363   MATCH_label_a296: (void)0; /*placeholder for label*/ 
39364     { 
39365       unsigned Eaddr = 2 + addressToPC(MATCH_p);
39366       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
39367       nextPC = 7 + MATCH_p; 
39368       
39369       #line 1117 "machine/pentium/disassembler.m"
39370       
39371 
39372               sprintf (str,  "ORrmow", DIS_REG16, DIS_EADDR16);
39373 
39374       
39375 
39376       
39377       
39378       
39379     } 
39380     goto MATCH_finished_a; 
39381     
39382   MATCH_label_a297: (void)0; /*placeholder for label*/ 
39383     { 
39384       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39385       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39386       nextPC = 4 + MATCH_p; 
39387       
39388       #line 790 "machine/pentium/disassembler.m"
39389       
39390 
39391               sprintf (str,  "LAR.ow", DIS_REG16, DIS_EADDR16);
39392 
39393       
39394 
39395       
39396       
39397       
39398     } 
39399     goto MATCH_finished_a; 
39400     
39401   MATCH_label_a298: (void)0; /*placeholder for label*/ 
39402     { 
39403       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39404       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39405       nextPC = 5 + MATCH_p; 
39406       
39407       #line 790 "machine/pentium/disassembler.m"
39408       
39409 
39410               sprintf (str,  "LAR.ow", DIS_REG16, DIS_EADDR16);
39411 
39412       
39413 
39414       
39415       
39416       
39417     } 
39418     goto MATCH_finished_a; 
39419     
39420   MATCH_label_a299: (void)0; /*placeholder for label*/ 
39421     { 
39422       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39423       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39424       nextPC = 9 + MATCH_p; 
39425       
39426       #line 790 "machine/pentium/disassembler.m"
39427       
39428 
39429               sprintf (str,  "LAR.ow", DIS_REG16, DIS_EADDR16);
39430 
39431       
39432 
39433       
39434       
39435       
39436     } 
39437     goto MATCH_finished_a; 
39438     
39439   MATCH_label_a300: (void)0; /*placeholder for label*/ 
39440     { 
39441       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39442       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39443       nextPC = 8 + MATCH_p; 
39444       
39445       #line 790 "machine/pentium/disassembler.m"
39446       
39447 
39448               sprintf (str,  "LAR.ow", DIS_REG16, DIS_EADDR16);
39449 
39450       
39451 
39452       
39453       
39454       
39455     } 
39456     goto MATCH_finished_a; 
39457     
39458   MATCH_label_a301: (void)0; /*placeholder for label*/ 
39459     { 
39460       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39461       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39462       nextPC = 4 + MATCH_p; 
39463       
39464       #line 754 "machine/pentium/disassembler.m"
39465       
39466 
39467               sprintf (str,  "LSLow", DIS_REG16, DIS_EADDR16);
39468 
39469       
39470 
39471       
39472       
39473       
39474     } 
39475     goto MATCH_finished_a; 
39476     
39477   MATCH_label_a302: (void)0; /*placeholder for label*/ 
39478     { 
39479       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39480       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39481       nextPC = 5 + MATCH_p; 
39482       
39483       #line 754 "machine/pentium/disassembler.m"
39484       
39485 
39486               sprintf (str,  "LSLow", DIS_REG16, DIS_EADDR16);
39487 
39488       
39489 
39490       
39491       
39492       
39493     } 
39494     goto MATCH_finished_a; 
39495     
39496   MATCH_label_a303: (void)0; /*placeholder for label*/ 
39497     { 
39498       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39499       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39500       nextPC = 9 + MATCH_p; 
39501       
39502       #line 754 "machine/pentium/disassembler.m"
39503       
39504 
39505               sprintf (str,  "LSLow", DIS_REG16, DIS_EADDR16);
39506 
39507       
39508 
39509       
39510       
39511       
39512     } 
39513     goto MATCH_finished_a; 
39514     
39515   MATCH_label_a304: (void)0; /*placeholder for label*/ 
39516     { 
39517       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39518       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39519       nextPC = 8 + MATCH_p; 
39520       
39521       #line 754 "machine/pentium/disassembler.m"
39522       
39523 
39524               sprintf (str,  "LSLow", DIS_REG16, DIS_EADDR16);
39525 
39526       
39527 
39528       
39529       
39530       
39531     } 
39532     goto MATCH_finished_a; 
39533     
39534   MATCH_label_a305: (void)0; /*placeholder for label*/ 
39535     { 
39536       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39537       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39538       nextPC = 4 + MATCH_p; 
39539       
39540       #line 1037 "machine/pentium/disassembler.m"
39541       
39542 
39543               sprintf (str,  "BTow", DIS_EADDR16, DIS_REG16);
39544 
39545       
39546 
39547       
39548       
39549       
39550     } 
39551     goto MATCH_finished_a; 
39552     
39553   MATCH_label_a306: (void)0; /*placeholder for label*/ 
39554     { 
39555       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39556       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39557       nextPC = 5 + MATCH_p; 
39558       
39559       #line 1037 "machine/pentium/disassembler.m"
39560       
39561 
39562               sprintf (str,  "BTow", DIS_EADDR16, DIS_REG16);
39563 
39564       
39565 
39566       
39567       
39568       
39569     } 
39570     goto MATCH_finished_a; 
39571     
39572   MATCH_label_a307: (void)0; /*placeholder for label*/ 
39573     { 
39574       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39575       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39576       nextPC = 9 + MATCH_p; 
39577       
39578       #line 1037 "machine/pentium/disassembler.m"
39579       
39580 
39581               sprintf (str,  "BTow", DIS_EADDR16, DIS_REG16);
39582 
39583       
39584 
39585       
39586       
39587       
39588     } 
39589     goto MATCH_finished_a; 
39590     
39591   MATCH_label_a308: (void)0; /*placeholder for label*/ 
39592     { 
39593       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39594       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39595       nextPC = 8 + MATCH_p; 
39596       
39597       #line 1037 "machine/pentium/disassembler.m"
39598       
39599 
39600               sprintf (str,  "BTow", DIS_EADDR16, DIS_REG16);
39601 
39602       
39603 
39604       
39605       
39606       
39607     } 
39608     goto MATCH_finished_a; 
39609     
39610   MATCH_label_a309: (void)0; /*placeholder for label*/ 
39611     { 
39612       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39613       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39614       nextPC = 4 + MATCH_p; 
39615       
39616       #line 1001 "machine/pentium/disassembler.m"
39617       
39618 
39619               sprintf (str,  "BTSow", DIS_EADDR16, DIS_REG16);
39620 
39621       
39622 
39623       
39624       
39625       
39626     } 
39627     goto MATCH_finished_a; 
39628     
39629   MATCH_label_a310: (void)0; /*placeholder for label*/ 
39630     { 
39631       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39632       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39633       nextPC = 5 + MATCH_p; 
39634       
39635       #line 1001 "machine/pentium/disassembler.m"
39636       
39637 
39638               sprintf (str,  "BTSow", DIS_EADDR16, DIS_REG16);
39639 
39640       
39641 
39642       
39643       
39644       
39645     } 
39646     goto MATCH_finished_a; 
39647     
39648   MATCH_label_a311: (void)0; /*placeholder for label*/ 
39649     { 
39650       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39651       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39652       nextPC = 9 + MATCH_p; 
39653       
39654       #line 1001 "machine/pentium/disassembler.m"
39655       
39656 
39657               sprintf (str,  "BTSow", DIS_EADDR16, DIS_REG16);
39658 
39659       
39660 
39661       
39662       
39663       
39664     } 
39665     goto MATCH_finished_a; 
39666     
39667   MATCH_label_a312: (void)0; /*placeholder for label*/ 
39668     { 
39669       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39670       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39671       nextPC = 8 + MATCH_p; 
39672       
39673       #line 1001 "machine/pentium/disassembler.m"
39674       
39675 
39676               sprintf (str,  "BTSow", DIS_EADDR16, DIS_REG16);
39677 
39678       
39679 
39680       
39681       
39682       
39683     } 
39684     goto MATCH_finished_a; 
39685     
39686   MATCH_label_a313: (void)0; /*placeholder for label*/ 
39687     { 
39688       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39689       unsigned count = (MATCH_w_8_32 & 0xff) /* i8 at 32 */;
39690       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39691       nextPC = 5 + MATCH_p; 
39692       
39693       #line 164 "machine/pentium/disassembler.m"
39694       
39695 
39696               sprintf (str,  "SHLD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
39697 
39698       
39699 
39700       
39701       
39702       
39703     } 
39704     goto MATCH_finished_a; 
39705     
39706   MATCH_label_a314: (void)0; /*placeholder for label*/ 
39707     { 
39708       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39709       unsigned count = (MATCH_w_8_40 & 0xff) /* i8 at 40 */;
39710       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39711       nextPC = 6 + MATCH_p; 
39712       
39713       #line 164 "machine/pentium/disassembler.m"
39714       
39715 
39716               sprintf (str,  "SHLD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
39717 
39718       
39719 
39720       
39721       
39722       
39723     } 
39724     goto MATCH_finished_a; 
39725     
39726   MATCH_label_a315: (void)0; /*placeholder for label*/ 
39727     { 
39728       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39729       unsigned count = (MATCH_w_8_72 & 0xff) /* i8 at 72 */;
39730       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39731       nextPC = 10 + MATCH_p; 
39732       
39733       #line 164 "machine/pentium/disassembler.m"
39734       
39735 
39736               sprintf (str,  "SHLD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
39737 
39738       
39739 
39740       
39741       
39742       
39743     } 
39744     goto MATCH_finished_a; 
39745     
39746   MATCH_label_a316: (void)0; /*placeholder for label*/ 
39747     { 
39748       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39749       unsigned count = (MATCH_w_8_64 & 0xff) /* i8 at 64 */;
39750       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39751       nextPC = 9 + MATCH_p; 
39752       
39753       #line 164 "machine/pentium/disassembler.m"
39754       
39755 
39756               sprintf (str,  "SHLD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
39757 
39758       
39759 
39760       
39761       
39762       
39763     } 
39764     goto MATCH_finished_a; 
39765     
39766   MATCH_label_a317: (void)0; /*placeholder for label*/ 
39767     { 
39768       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39769       unsigned count = (MATCH_w_8_32 & 0xff) /* i8 at 32 */;
39770       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39771       nextPC = 5 + MATCH_p; 
39772       
39773       #line 170 "machine/pentium/disassembler.m"
39774       
39775 
39776               sprintf (str,  "SHRD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
39777 
39778       
39779 
39780       
39781       
39782       
39783     } 
39784     goto MATCH_finished_a; 
39785     
39786   MATCH_label_a318: (void)0; /*placeholder for label*/ 
39787     { 
39788       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39789       unsigned count = (MATCH_w_8_40 & 0xff) /* i8 at 40 */;
39790       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39791       nextPC = 6 + MATCH_p; 
39792       
39793       #line 170 "machine/pentium/disassembler.m"
39794       
39795 
39796               sprintf (str,  "SHRD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
39797 
39798       
39799 
39800       
39801       
39802       
39803     } 
39804     goto MATCH_finished_a; 
39805     
39806   MATCH_label_a319: (void)0; /*placeholder for label*/ 
39807     { 
39808       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39809       unsigned count = (MATCH_w_8_72 & 0xff) /* i8 at 72 */;
39810       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39811       nextPC = 10 + MATCH_p; 
39812       
39813       #line 170 "machine/pentium/disassembler.m"
39814       
39815 
39816               sprintf (str,  "SHRD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
39817 
39818       
39819 
39820       
39821       
39822       
39823     } 
39824     goto MATCH_finished_a; 
39825     
39826   MATCH_label_a320: (void)0; /*placeholder for label*/ 
39827     { 
39828       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39829       unsigned count = (MATCH_w_8_64 & 0xff) /* i8 at 64 */;
39830       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39831       nextPC = 9 + MATCH_p; 
39832       
39833       #line 170 "machine/pentium/disassembler.m"
39834       
39835 
39836               sprintf (str,  "SHRD.Ibow", DIS_EADDR16, DIS_REG16, DIS_COUNT);
39837 
39838       
39839 
39840       
39841       
39842       
39843     } 
39844     goto MATCH_finished_a; 
39845     
39846   MATCH_label_a321: (void)0; /*placeholder for label*/ 
39847     { 
39848       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39849       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39850       nextPC = 4 + MATCH_p; 
39851       
39852       #line 152 "machine/pentium/disassembler.m"
39853       
39854 
39855               sprintf (str,  "SHLD.CLow", DIS_EADDR16, DIS_REG16);
39856 
39857       
39858 
39859       
39860       
39861       
39862     } 
39863     goto MATCH_finished_a; 
39864     
39865   MATCH_label_a322: (void)0; /*placeholder for label*/ 
39866     { 
39867       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39868       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39869       nextPC = 5 + MATCH_p; 
39870       
39871       #line 152 "machine/pentium/disassembler.m"
39872       
39873 
39874               sprintf (str,  "SHLD.CLow", DIS_EADDR16, DIS_REG16);
39875 
39876       
39877 
39878       
39879       
39880       
39881     } 
39882     goto MATCH_finished_a; 
39883     
39884   MATCH_label_a323: (void)0; /*placeholder for label*/ 
39885     { 
39886       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39887       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39888       nextPC = 9 + MATCH_p; 
39889       
39890       #line 152 "machine/pentium/disassembler.m"
39891       
39892 
39893               sprintf (str,  "SHLD.CLow", DIS_EADDR16, DIS_REG16);
39894 
39895       
39896 
39897       
39898       
39899       
39900     } 
39901     goto MATCH_finished_a; 
39902     
39903   MATCH_label_a324: (void)0; /*placeholder for label*/ 
39904     { 
39905       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39906       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39907       nextPC = 8 + MATCH_p; 
39908       
39909       #line 152 "machine/pentium/disassembler.m"
39910       
39911 
39912               sprintf (str,  "SHLD.CLow", DIS_EADDR16, DIS_REG16);
39913 
39914       
39915 
39916       
39917       
39918       
39919     } 
39920     goto MATCH_finished_a; 
39921     
39922   MATCH_label_a325: (void)0; /*placeholder for label*/ 
39923     { 
39924       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39925       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39926       nextPC = 4 + MATCH_p; 
39927       
39928       #line 158 "machine/pentium/disassembler.m"
39929       
39930 
39931               sprintf (str,  "SHRD.CLow", DIS_EADDR16, DIS_REG16);
39932 
39933       
39934 
39935       
39936       
39937       
39938     } 
39939     goto MATCH_finished_a; 
39940     
39941   MATCH_label_a326: (void)0; /*placeholder for label*/ 
39942     { 
39943       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39944       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39945       nextPC = 5 + MATCH_p; 
39946       
39947       #line 158 "machine/pentium/disassembler.m"
39948       
39949 
39950               sprintf (str,  "SHRD.CLow", DIS_EADDR16, DIS_REG16);
39951 
39952       
39953 
39954       
39955       
39956       
39957     } 
39958     goto MATCH_finished_a; 
39959     
39960   MATCH_label_a327: (void)0; /*placeholder for label*/ 
39961     { 
39962       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39963       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39964       nextPC = 9 + MATCH_p; 
39965       
39966       #line 158 "machine/pentium/disassembler.m"
39967       
39968 
39969               sprintf (str,  "SHRD.CLow", DIS_EADDR16, DIS_REG16);
39970 
39971       
39972 
39973       
39974       
39975       
39976     } 
39977     goto MATCH_finished_a; 
39978     
39979   MATCH_label_a328: (void)0; /*placeholder for label*/ 
39980     { 
39981       unsigned Eaddr = 3 + addressToPC(MATCH_p);
39982       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
39983       nextPC = 8 + MATCH_p; 
39984       
39985       #line 158 "machine/pentium/disassembler.m"
39986       
39987 
39988               sprintf (str,  "SHRD.CLow", DIS_EADDR16, DIS_REG16);
39989 
39990       
39991 
39992       
39993       
39994       
39995     } 
39996     goto MATCH_finished_a; 
39997     
39998   MATCH_label_a329: (void)0; /*placeholder for label*/ 
39999     { 
40000       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40001       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40002       nextPC = 4 + MATCH_p; 
40003       
40004       #line 872 "machine/pentium/disassembler.m"
40005       
40006 
40007               sprintf (str,  "IMULrmow", DIS_REG16, DIS_EADDR16);
40008 
40009       
40010 
40011       
40012       
40013       
40014     } 
40015     goto MATCH_finished_a; 
40016     
40017   MATCH_label_a330: (void)0; /*placeholder for label*/ 
40018     { 
40019       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40020       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40021       nextPC = 5 + MATCH_p; 
40022       
40023       #line 872 "machine/pentium/disassembler.m"
40024       
40025 
40026               sprintf (str,  "IMULrmow", DIS_REG16, DIS_EADDR16);
40027 
40028       
40029 
40030       
40031       
40032       
40033     } 
40034     goto MATCH_finished_a; 
40035     
40036   MATCH_label_a331: (void)0; /*placeholder for label*/ 
40037     { 
40038       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40039       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40040       nextPC = 9 + MATCH_p; 
40041       
40042       #line 872 "machine/pentium/disassembler.m"
40043       
40044 
40045               sprintf (str,  "IMULrmow", DIS_REG16, DIS_EADDR16);
40046 
40047       
40048 
40049       
40050       
40051       
40052     } 
40053     goto MATCH_finished_a; 
40054     
40055   MATCH_label_a332: (void)0; /*placeholder for label*/ 
40056     { 
40057       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40058       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40059       nextPC = 8 + MATCH_p; 
40060       
40061       #line 872 "machine/pentium/disassembler.m"
40062       
40063 
40064               sprintf (str,  "IMULrmow", DIS_REG16, DIS_EADDR16);
40065 
40066       
40067 
40068       
40069       
40070       
40071     } 
40072     goto MATCH_finished_a; 
40073     
40074   MATCH_label_a333: (void)0; /*placeholder for label*/ 
40075     { 
40076       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40077       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40078       nextPC = 4 + MATCH_p; 
40079       
40080       #line 944 "machine/pentium/disassembler.m"
40081       
40082 
40083               sprintf (str,  "CMPXCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
40084 
40085       
40086 
40087       
40088       
40089       
40090     } 
40091     goto MATCH_finished_a; 
40092     
40093   MATCH_label_a334: (void)0; /*placeholder for label*/ 
40094     { 
40095       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40096       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40097       nextPC = 5 + MATCH_p; 
40098       
40099       #line 944 "machine/pentium/disassembler.m"
40100       
40101 
40102               sprintf (str,  "CMPXCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
40103 
40104       
40105 
40106       
40107       
40108       
40109     } 
40110     goto MATCH_finished_a; 
40111     
40112   MATCH_label_a335: (void)0; /*placeholder for label*/ 
40113     { 
40114       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40115       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40116       nextPC = 9 + MATCH_p; 
40117       
40118       #line 944 "machine/pentium/disassembler.m"
40119       
40120 
40121               sprintf (str,  "CMPXCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
40122 
40123       
40124 
40125       
40126       
40127       
40128     } 
40129     goto MATCH_finished_a; 
40130     
40131   MATCH_label_a336: (void)0; /*placeholder for label*/ 
40132     { 
40133       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40134       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40135       nextPC = 8 + MATCH_p; 
40136       
40137       #line 944 "machine/pentium/disassembler.m"
40138       
40139 
40140               sprintf (str,  "CMPXCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
40141 
40142       
40143 
40144       
40145       
40146       
40147     } 
40148     goto MATCH_finished_a; 
40149     
40150   MATCH_label_a337: (void)0; /*placeholder for label*/ 
40151     { 
40152       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40153       int /* [~128..127] */ i8 = 
40154         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
40155       nextPC = 5 + MATCH_p; 
40156       
40157       #line 1031 "machine/pentium/disassembler.m"
40158       
40159 
40160               sprintf (str,  "BTiow", DIS_EADDR16, DIS_I8);
40161 
40162       
40163 
40164       
40165       
40166       
40167     } 
40168     goto MATCH_finished_a; 
40169     
40170   MATCH_label_a338: (void)0; /*placeholder for label*/ 
40171     { 
40172       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40173       int /* [~128..127] */ i8 = 
40174         sign_extend((MATCH_w_8_40 & 0xff) /* i8 at 40 */, 8);
40175       nextPC = 6 + MATCH_p; 
40176       
40177       #line 1031 "machine/pentium/disassembler.m"
40178       
40179 
40180               sprintf (str,  "BTiow", DIS_EADDR16, DIS_I8);
40181 
40182       
40183 
40184       
40185       
40186       
40187     } 
40188     goto MATCH_finished_a; 
40189     
40190   MATCH_label_a339: (void)0; /*placeholder for label*/ 
40191     { 
40192       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40193       int /* [~128..127] */ i8 = 
40194         sign_extend((MATCH_w_8_72 & 0xff) /* i8 at 72 */, 8);
40195       nextPC = 10 + MATCH_p; 
40196       
40197       #line 1031 "machine/pentium/disassembler.m"
40198       
40199 
40200               sprintf (str,  "BTiow", DIS_EADDR16, DIS_I8);
40201 
40202       
40203 
40204       
40205       
40206       
40207     } 
40208     goto MATCH_finished_a; 
40209     
40210   MATCH_label_a340: (void)0; /*placeholder for label*/ 
40211     { 
40212       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40213       int /* [~128..127] */ i8 = 
40214         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
40215       nextPC = 9 + MATCH_p; 
40216       
40217       #line 1031 "machine/pentium/disassembler.m"
40218       
40219 
40220               sprintf (str,  "BTiow", DIS_EADDR16, DIS_I8);
40221 
40222       
40223 
40224       
40225       
40226       
40227     } 
40228     goto MATCH_finished_a; 
40229     
40230   MATCH_label_a341: (void)0; /*placeholder for label*/ 
40231     { 
40232       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40233       int /* [~128..127] */ i8 = 
40234         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
40235       nextPC = 5 + MATCH_p; 
40236       
40237       #line 995 "machine/pentium/disassembler.m"
40238       
40239 
40240               sprintf (str,  "BTSiow", DIS_I8, DIS_EADDR16);
40241 
40242       
40243 
40244       
40245       
40246       
40247     } 
40248     goto MATCH_finished_a; 
40249     
40250   MATCH_label_a342: (void)0; /*placeholder for label*/ 
40251     { 
40252       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40253       int /* [~128..127] */ i8 = 
40254         sign_extend((MATCH_w_8_40 & 0xff) /* i8 at 40 */, 8);
40255       nextPC = 6 + MATCH_p; 
40256       
40257       #line 995 "machine/pentium/disassembler.m"
40258       
40259 
40260               sprintf (str,  "BTSiow", DIS_I8, DIS_EADDR16);
40261 
40262       
40263 
40264       
40265       
40266       
40267     } 
40268     goto MATCH_finished_a; 
40269     
40270   MATCH_label_a343: (void)0; /*placeholder for label*/ 
40271     { 
40272       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40273       int /* [~128..127] */ i8 = 
40274         sign_extend((MATCH_w_8_72 & 0xff) /* i8 at 72 */, 8);
40275       nextPC = 10 + MATCH_p; 
40276       
40277       #line 995 "machine/pentium/disassembler.m"
40278       
40279 
40280               sprintf (str,  "BTSiow", DIS_I8, DIS_EADDR16);
40281 
40282       
40283 
40284       
40285       
40286       
40287     } 
40288     goto MATCH_finished_a; 
40289     
40290   MATCH_label_a344: (void)0; /*placeholder for label*/ 
40291     { 
40292       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40293       int /* [~128..127] */ i8 = 
40294         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
40295       nextPC = 9 + MATCH_p; 
40296       
40297       #line 995 "machine/pentium/disassembler.m"
40298       
40299 
40300               sprintf (str,  "BTSiow", DIS_I8, DIS_EADDR16);
40301 
40302       
40303 
40304       
40305       
40306       
40307     } 
40308     goto MATCH_finished_a; 
40309     
40310   MATCH_label_a345: (void)0; /*placeholder for label*/ 
40311     { 
40312       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40313       int /* [~128..127] */ i8 = 
40314         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
40315       nextPC = 5 + MATCH_p; 
40316       
40317       #line 1007 "machine/pentium/disassembler.m"
40318       
40319 
40320               sprintf (str,  "BTRiow", DIS_EADDR16, DIS_I8);
40321 
40322       
40323 
40324       
40325       
40326       
40327     } 
40328     goto MATCH_finished_a; 
40329     
40330   MATCH_label_a346: (void)0; /*placeholder for label*/ 
40331     { 
40332       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40333       int /* [~128..127] */ i8 = 
40334         sign_extend((MATCH_w_8_40 & 0xff) /* i8 at 40 */, 8);
40335       nextPC = 6 + MATCH_p; 
40336       
40337       #line 1007 "machine/pentium/disassembler.m"
40338       
40339 
40340               sprintf (str,  "BTRiow", DIS_EADDR16, DIS_I8);
40341 
40342       
40343 
40344       
40345       
40346       
40347     } 
40348     goto MATCH_finished_a; 
40349     
40350   MATCH_label_a347: (void)0; /*placeholder for label*/ 
40351     { 
40352       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40353       int /* [~128..127] */ i8 = 
40354         sign_extend((MATCH_w_8_72 & 0xff) /* i8 at 72 */, 8);
40355       nextPC = 10 + MATCH_p; 
40356       
40357       #line 1007 "machine/pentium/disassembler.m"
40358       
40359 
40360               sprintf (str,  "BTRiow", DIS_EADDR16, DIS_I8);
40361 
40362       
40363 
40364       
40365       
40366       
40367     } 
40368     goto MATCH_finished_a; 
40369     
40370   MATCH_label_a348: (void)0; /*placeholder for label*/ 
40371     { 
40372       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40373       int /* [~128..127] */ i8 = 
40374         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
40375       nextPC = 9 + MATCH_p; 
40376       
40377       #line 1007 "machine/pentium/disassembler.m"
40378       
40379 
40380               sprintf (str,  "BTRiow", DIS_EADDR16, DIS_I8);
40381 
40382       
40383 
40384       
40385       
40386       
40387     } 
40388     goto MATCH_finished_a; 
40389     
40390   MATCH_label_a349: (void)0; /*placeholder for label*/ 
40391     { 
40392       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40393       int /* [~128..127] */ i8 = 
40394         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
40395       nextPC = 5 + MATCH_p; 
40396       
40397       #line 1019 "machine/pentium/disassembler.m"
40398       
40399 
40400               sprintf (str,  "BTCiow", DIS_EADDR16, DIS_I8);
40401 
40402       
40403 
40404       
40405       
40406       
40407     } 
40408     goto MATCH_finished_a; 
40409     
40410   MATCH_label_a350: (void)0; /*placeholder for label*/ 
40411     { 
40412       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40413       int /* [~128..127] */ i8 = 
40414         sign_extend((MATCH_w_8_40 & 0xff) /* i8 at 40 */, 8);
40415       nextPC = 6 + MATCH_p; 
40416       
40417       #line 1019 "machine/pentium/disassembler.m"
40418       
40419 
40420               sprintf (str,  "BTCiow", DIS_EADDR16, DIS_I8);
40421 
40422       
40423 
40424       
40425       
40426       
40427     } 
40428     goto MATCH_finished_a; 
40429     
40430   MATCH_label_a351: (void)0; /*placeholder for label*/ 
40431     { 
40432       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40433       int /* [~128..127] */ i8 = 
40434         sign_extend((MATCH_w_8_72 & 0xff) /* i8 at 72 */, 8);
40435       nextPC = 10 + MATCH_p; 
40436       
40437       #line 1019 "machine/pentium/disassembler.m"
40438       
40439 
40440               sprintf (str,  "BTCiow", DIS_EADDR16, DIS_I8);
40441 
40442       
40443 
40444       
40445       
40446       
40447     } 
40448     goto MATCH_finished_a; 
40449     
40450   MATCH_label_a352: (void)0; /*placeholder for label*/ 
40451     { 
40452       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40453       int /* [~128..127] */ i8 = 
40454         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
40455       nextPC = 9 + MATCH_p; 
40456       
40457       #line 1019 "machine/pentium/disassembler.m"
40458       
40459 
40460               sprintf (str,  "BTCiow", DIS_EADDR16, DIS_I8);
40461 
40462       
40463 
40464       
40465       
40466       
40467     } 
40468     goto MATCH_finished_a; 
40469     
40470   MATCH_label_a353: (void)0; /*placeholder for label*/ 
40471     { 
40472       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40473       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40474       nextPC = 4 + MATCH_p; 
40475       
40476       #line 1013 "machine/pentium/disassembler.m"
40477       
40478 
40479               sprintf (str,  "BTRow", DIS_EADDR16, DIS_REG16);
40480 
40481       
40482 
40483       
40484       
40485       
40486     } 
40487     goto MATCH_finished_a; 
40488     
40489   MATCH_label_a354: (void)0; /*placeholder for label*/ 
40490     { 
40491       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40492       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40493       nextPC = 5 + MATCH_p; 
40494       
40495       #line 1013 "machine/pentium/disassembler.m"
40496       
40497 
40498               sprintf (str,  "BTRow", DIS_EADDR16, DIS_REG16);
40499 
40500       
40501 
40502       
40503       
40504       
40505     } 
40506     goto MATCH_finished_a; 
40507     
40508   MATCH_label_a355: (void)0; /*placeholder for label*/ 
40509     { 
40510       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40511       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40512       nextPC = 9 + MATCH_p; 
40513       
40514       #line 1013 "machine/pentium/disassembler.m"
40515       
40516 
40517               sprintf (str,  "BTRow", DIS_EADDR16, DIS_REG16);
40518 
40519       
40520 
40521       
40522       
40523       
40524     } 
40525     goto MATCH_finished_a; 
40526     
40527   MATCH_label_a356: (void)0; /*placeholder for label*/ 
40528     { 
40529       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40530       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40531       nextPC = 8 + MATCH_p; 
40532       
40533       #line 1013 "machine/pentium/disassembler.m"
40534       
40535 
40536               sprintf (str,  "BTRow", DIS_EADDR16, DIS_REG16);
40537 
40538       
40539 
40540       
40541       
40542       
40543     } 
40544     goto MATCH_finished_a; 
40545     
40546   MATCH_label_a357: (void)0; /*placeholder for label*/ 
40547     { 
40548       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40549       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40550       nextPC = 4 + MATCH_p; 
40551       
40552       #line 1025 "machine/pentium/disassembler.m"
40553       
40554 
40555               sprintf (str,  "BTCow", DIS_EADDR16, DIS_REG16);
40556 
40557       
40558 
40559       
40560       
40561       
40562     } 
40563     goto MATCH_finished_a; 
40564     
40565   MATCH_label_a358: (void)0; /*placeholder for label*/ 
40566     { 
40567       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40568       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40569       nextPC = 5 + MATCH_p; 
40570       
40571       #line 1025 "machine/pentium/disassembler.m"
40572       
40573 
40574               sprintf (str,  "BTCow", DIS_EADDR16, DIS_REG16);
40575 
40576       
40577 
40578       
40579       
40580       
40581     } 
40582     goto MATCH_finished_a; 
40583     
40584   MATCH_label_a359: (void)0; /*placeholder for label*/ 
40585     { 
40586       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40587       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40588       nextPC = 9 + MATCH_p; 
40589       
40590       #line 1025 "machine/pentium/disassembler.m"
40591       
40592 
40593               sprintf (str,  "BTCow", DIS_EADDR16, DIS_REG16);
40594 
40595       
40596 
40597       
40598       
40599       
40600     } 
40601     goto MATCH_finished_a; 
40602     
40603   MATCH_label_a360: (void)0; /*placeholder for label*/ 
40604     { 
40605       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40606       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40607       nextPC = 8 + MATCH_p; 
40608       
40609       #line 1025 "machine/pentium/disassembler.m"
40610       
40611 
40612               sprintf (str,  "BTCow", DIS_EADDR16, DIS_REG16);
40613 
40614       
40615 
40616       
40617       
40618       
40619     } 
40620     goto MATCH_finished_a; 
40621     
40622   MATCH_label_a361: (void)0; /*placeholder for label*/ 
40623     { 
40624       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40625       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40626       nextPC = 4 + MATCH_p; 
40627       
40628       #line 1052 "machine/pentium/disassembler.m"
40629       
40630 
40631               sprintf (str,  "BSFow", DIS_REG16, DIS_EADDR16);
40632 
40633       
40634 
40635           // Not "user" instructions:
40636 
40637       //  | BOUNDod(reg, Mem) =>
40638 
40639       //      sprintf (str,  "BOUNDod", DIS_REG32, DIS_MEM);
40640 
40641       
40642 
40643       //  | BOUNDow(reg, Mem) =>
40644 
40645       //      sprintf (str,  "BOUNDow", DIS_REG16, DIS_MEM);
40646 
40647       
40648 
40649       //    | ARPL(Eaddr, reg ) =>
40650 
40651       //        unused(Eaddr); unused(reg);
40652 
40653       //        sprintf (str,  "UNIMP");
40654 
40655       
40656 
40657       //    | AAS() =>
40658 
40659       //        sprintf (str,  "AAS");
40660 
40661       
40662 
40663       //    | AAM() =>
40664 
40665       //        sprintf (str,  "AAM");
40666 
40667       
40668 
40669       //    | AAD() =>
40670 
40671       //        sprintf (str,  "AAD");
40672 
40673       
40674 
40675       //    | AAA() =>
40676 
40677       //        sprintf (str,  "AAA");
40678 
40679       
40680 
40681       
40682       
40683       
40684     } 
40685     goto MATCH_finished_a; 
40686     
40687   MATCH_label_a362: (void)0; /*placeholder for label*/ 
40688     { 
40689       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40690       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40691       nextPC = 5 + MATCH_p; 
40692       
40693       #line 1052 "machine/pentium/disassembler.m"
40694       
40695 
40696               sprintf (str,  "BSFow", DIS_REG16, DIS_EADDR16);
40697 
40698       
40699 
40700           // Not "user" instructions:
40701 
40702       //  | BOUNDod(reg, Mem) =>
40703 
40704       //      sprintf (str,  "BOUNDod", DIS_REG32, DIS_MEM);
40705 
40706       
40707 
40708       //  | BOUNDow(reg, Mem) =>
40709 
40710       //      sprintf (str,  "BOUNDow", DIS_REG16, DIS_MEM);
40711 
40712       
40713 
40714       //    | ARPL(Eaddr, reg ) =>
40715 
40716       //        unused(Eaddr); unused(reg);
40717 
40718       //        sprintf (str,  "UNIMP");
40719 
40720       
40721 
40722       //    | AAS() =>
40723 
40724       //        sprintf (str,  "AAS");
40725 
40726       
40727 
40728       //    | AAM() =>
40729 
40730       //        sprintf (str,  "AAM");
40731 
40732       
40733 
40734       //    | AAD() =>
40735 
40736       //        sprintf (str,  "AAD");
40737 
40738       
40739 
40740       //    | AAA() =>
40741 
40742       //        sprintf (str,  "AAA");
40743 
40744       
40745 
40746       
40747       
40748       
40749     } 
40750     goto MATCH_finished_a; 
40751     
40752   MATCH_label_a363: (void)0; /*placeholder for label*/ 
40753     { 
40754       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40755       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40756       nextPC = 9 + MATCH_p; 
40757       
40758       #line 1052 "machine/pentium/disassembler.m"
40759       
40760 
40761               sprintf (str,  "BSFow", DIS_REG16, DIS_EADDR16);
40762 
40763       
40764 
40765           // Not "user" instructions:
40766 
40767       //  | BOUNDod(reg, Mem) =>
40768 
40769       //      sprintf (str,  "BOUNDod", DIS_REG32, DIS_MEM);
40770 
40771       
40772 
40773       //  | BOUNDow(reg, Mem) =>
40774 
40775       //      sprintf (str,  "BOUNDow", DIS_REG16, DIS_MEM);
40776 
40777       
40778 
40779       //    | ARPL(Eaddr, reg ) =>
40780 
40781       //        unused(Eaddr); unused(reg);
40782 
40783       //        sprintf (str,  "UNIMP");
40784 
40785       
40786 
40787       //    | AAS() =>
40788 
40789       //        sprintf (str,  "AAS");
40790 
40791       
40792 
40793       //    | AAM() =>
40794 
40795       //        sprintf (str,  "AAM");
40796 
40797       
40798 
40799       //    | AAD() =>
40800 
40801       //        sprintf (str,  "AAD");
40802 
40803       
40804 
40805       //    | AAA() =>
40806 
40807       //        sprintf (str,  "AAA");
40808 
40809       
40810 
40811       
40812       
40813       
40814     } 
40815     goto MATCH_finished_a; 
40816     
40817   MATCH_label_a364: (void)0; /*placeholder for label*/ 
40818     { 
40819       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40820       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40821       nextPC = 8 + MATCH_p; 
40822       
40823       #line 1052 "machine/pentium/disassembler.m"
40824       
40825 
40826               sprintf (str,  "BSFow", DIS_REG16, DIS_EADDR16);
40827 
40828       
40829 
40830           // Not "user" instructions:
40831 
40832       //  | BOUNDod(reg, Mem) =>
40833 
40834       //      sprintf (str,  "BOUNDod", DIS_REG32, DIS_MEM);
40835 
40836       
40837 
40838       //  | BOUNDow(reg, Mem) =>
40839 
40840       //      sprintf (str,  "BOUNDow", DIS_REG16, DIS_MEM);
40841 
40842       
40843 
40844       //    | ARPL(Eaddr, reg ) =>
40845 
40846       //        unused(Eaddr); unused(reg);
40847 
40848       //        sprintf (str,  "UNIMP");
40849 
40850       
40851 
40852       //    | AAS() =>
40853 
40854       //        sprintf (str,  "AAS");
40855 
40856       
40857 
40858       //    | AAM() =>
40859 
40860       //        sprintf (str,  "AAM");
40861 
40862       
40863 
40864       //    | AAD() =>
40865 
40866       //        sprintf (str,  "AAD");
40867 
40868       
40869 
40870       //    | AAA() =>
40871 
40872       //        sprintf (str,  "AAA");
40873 
40874       
40875 
40876       
40877       
40878       
40879     } 
40880     goto MATCH_finished_a; 
40881     
40882   MATCH_label_a365: (void)0; /*placeholder for label*/ 
40883     { 
40884       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40885       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40886       nextPC = 4 + MATCH_p; 
40887       
40888       #line 1046 "machine/pentium/disassembler.m"
40889       
40890 
40891               sprintf (str,  "BSRow", DIS_REG16, DIS_EADDR16);
40892 
40893       
40894 
40895       
40896       
40897       
40898     } 
40899     goto MATCH_finished_a; 
40900     
40901   MATCH_label_a366: (void)0; /*placeholder for label*/ 
40902     { 
40903       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40904       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40905       nextPC = 5 + MATCH_p; 
40906       
40907       #line 1046 "machine/pentium/disassembler.m"
40908       
40909 
40910               sprintf (str,  "BSRow", DIS_REG16, DIS_EADDR16);
40911 
40912       
40913 
40914       
40915       
40916       
40917     } 
40918     goto MATCH_finished_a; 
40919     
40920   MATCH_label_a367: (void)0; /*placeholder for label*/ 
40921     { 
40922       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40923       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40924       nextPC = 9 + MATCH_p; 
40925       
40926       #line 1046 "machine/pentium/disassembler.m"
40927       
40928 
40929               sprintf (str,  "BSRow", DIS_REG16, DIS_EADDR16);
40930 
40931       
40932 
40933       
40934       
40935       
40936     } 
40937     goto MATCH_finished_a; 
40938     
40939   MATCH_label_a368: (void)0; /*placeholder for label*/ 
40940     { 
40941       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40942       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40943       nextPC = 8 + MATCH_p; 
40944       
40945       #line 1046 "machine/pentium/disassembler.m"
40946       
40947 
40948               sprintf (str,  "BSRow", DIS_REG16, DIS_EADDR16);
40949 
40950       
40951 
40952       
40953       
40954       
40955     } 
40956     goto MATCH_finished_a; 
40957     
40958   MATCH_label_a369: (void)0; /*placeholder for label*/ 
40959     { 
40960       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40961       unsigned r16 = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40962       nextPC = 4 + MATCH_p; 
40963       
40964       #line 648 "machine/pentium/disassembler.m"
40965       
40966 
40967               sprintf (str,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
40968 
40969       
40970 
40971       
40972       
40973       
40974     } 
40975     goto MATCH_finished_a; 
40976     
40977   MATCH_label_a370: (void)0; /*placeholder for label*/ 
40978     { 
40979       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40980       unsigned r16 = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
40981       nextPC = 5 + MATCH_p; 
40982       
40983       #line 648 "machine/pentium/disassembler.m"
40984       
40985 
40986               sprintf (str,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
40987 
40988       
40989 
40990       
40991       
40992       
40993     } 
40994     goto MATCH_finished_a; 
40995     
40996   MATCH_label_a371: (void)0; /*placeholder for label*/ 
40997     { 
40998       unsigned Eaddr = 3 + addressToPC(MATCH_p);
40999       unsigned r16 = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
41000       nextPC = 9 + MATCH_p; 
41001       
41002       #line 648 "machine/pentium/disassembler.m"
41003       
41004 
41005               sprintf (str,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
41006 
41007       
41008 
41009       
41010       
41011       
41012     } 
41013     goto MATCH_finished_a; 
41014     
41015   MATCH_label_a372: (void)0; /*placeholder for label*/ 
41016     { 
41017       unsigned Eaddr = 3 + addressToPC(MATCH_p);
41018       unsigned r16 = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
41019       nextPC = 8 + MATCH_p; 
41020       
41021       #line 648 "machine/pentium/disassembler.m"
41022       
41023 
41024               sprintf (str,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
41025 
41026       
41027 
41028       
41029       
41030       
41031     } 
41032     goto MATCH_finished_a; 
41033     
41034   MATCH_label_a373: (void)0; /*placeholder for label*/ 
41035     { 
41036       unsigned Eaddr = 3 + addressToPC(MATCH_p);
41037       unsigned r16 = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
41038       nextPC = 4 + MATCH_p; 
41039       
41040       #line 657 "machine/pentium/disassembler.m"
41041       
41042 
41043               sprintf (str,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
41044 
41045       
41046 
41047       
41048       
41049       
41050     } 
41051     goto MATCH_finished_a; 
41052     
41053   MATCH_label_a374: (void)0; /*placeholder for label*/ 
41054     { 
41055       unsigned Eaddr = 3 + addressToPC(MATCH_p);
41056       unsigned r16 = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
41057       nextPC = 5 + MATCH_p; 
41058       
41059       #line 657 "machine/pentium/disassembler.m"
41060       
41061 
41062               sprintf (str,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
41063 
41064       
41065 
41066       
41067       
41068       
41069     } 
41070     goto MATCH_finished_a; 
41071     
41072   MATCH_label_a375: (void)0; /*placeholder for label*/ 
41073     { 
41074       unsigned Eaddr = 3 + addressToPC(MATCH_p);
41075       unsigned r16 = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
41076       nextPC = 9 + MATCH_p; 
41077       
41078       #line 657 "machine/pentium/disassembler.m"
41079       
41080 
41081               sprintf (str,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
41082 
41083       
41084 
41085       
41086       
41087       
41088     } 
41089     goto MATCH_finished_a; 
41090     
41091   MATCH_label_a376: (void)0; /*placeholder for label*/ 
41092     { 
41093       unsigned Eaddr = 3 + addressToPC(MATCH_p);
41094       unsigned r16 = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
41095       nextPC = 8 + MATCH_p; 
41096       
41097       #line 657 "machine/pentium/disassembler.m"
41098       
41099 
41100               sprintf (str,  "MOVZX.Gv.Ebow", DIS_R16, DIS_EADDR8);
41101 
41102       
41103 
41104       
41105       
41106       
41107     } 
41108     goto MATCH_finished_a; 
41109     
41110   MATCH_label_a377: (void)0; /*placeholder for label*/ 
41111     { 
41112       unsigned Eaddr = 3 + addressToPC(MATCH_p);
41113       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
41114       nextPC = 4 + MATCH_p; 
41115       
41116       #line 74 "machine/pentium/disassembler.m"
41117       
41118 
41119               sprintf (str,  "XADD.Ev.Gvow", DIS_EADDR16, DIS_REG16);
41120 
41121       
41122 
41123       
41124       
41125       
41126     } 
41127     goto MATCH_finished_a; 
41128     
41129   MATCH_label_a378: (void)0; /*placeholder for label*/ 
41130     { 
41131       unsigned Eaddr = 3 + addressToPC(MATCH_p);
41132       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
41133       nextPC = 5 + MATCH_p; 
41134       
41135       #line 74 "machine/pentium/disassembler.m"
41136       
41137 
41138               sprintf (str,  "XADD.Ev.Gvow", DIS_EADDR16, DIS_REG16);
41139 
41140       
41141 
41142       
41143       
41144       
41145     } 
41146     goto MATCH_finished_a; 
41147     
41148   MATCH_label_a379: (void)0; /*placeholder for label*/ 
41149     { 
41150       unsigned Eaddr = 3 + addressToPC(MATCH_p);
41151       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
41152       nextPC = 9 + MATCH_p; 
41153       
41154       #line 74 "machine/pentium/disassembler.m"
41155       
41156 
41157               sprintf (str,  "XADD.Ev.Gvow", DIS_EADDR16, DIS_REG16);
41158 
41159       
41160 
41161       
41162       
41163       
41164     } 
41165     goto MATCH_finished_a; 
41166     
41167   MATCH_label_a380: (void)0; /*placeholder for label*/ 
41168     { 
41169       unsigned Eaddr = 3 + addressToPC(MATCH_p);
41170       unsigned reg = (MATCH_w_8_24 >> 3 & 0x7) /* reg_opcode at 24 */;
41171       nextPC = 8 + MATCH_p; 
41172       
41173       #line 74 "machine/pentium/disassembler.m"
41174       
41175 
41176               sprintf (str,  "XADD.Ev.Gvow", DIS_EADDR16, DIS_REG16);
41177 
41178       
41179 
41180       
41181       
41182       
41183     } 
41184     goto MATCH_finished_a; 
41185     
41186   MATCH_label_a381: (void)0; /*placeholder for label*/ 
41187     { 
41188       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41189       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41190       nextPC = 3 + MATCH_p; 
41191       
41192       #line 1183 "machine/pentium/disassembler.m"
41193       
41194 
41195               sprintf (str,  "ADCmrow", DIS_EADDR16, DIS_REG16);
41196 
41197       
41198 
41199       
41200       
41201       
41202     } 
41203     goto MATCH_finished_a; 
41204     
41205   MATCH_label_a382: (void)0; /*placeholder for label*/ 
41206     { 
41207       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41208       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41209       nextPC = 4 + MATCH_p; 
41210       
41211       #line 1183 "machine/pentium/disassembler.m"
41212       
41213 
41214               sprintf (str,  "ADCmrow", DIS_EADDR16, DIS_REG16);
41215 
41216       
41217 
41218       
41219       
41220       
41221     } 
41222     goto MATCH_finished_a; 
41223     
41224   MATCH_label_a383: (void)0; /*placeholder for label*/ 
41225     { 
41226       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41227       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41228       nextPC = 8 + MATCH_p; 
41229       
41230       #line 1183 "machine/pentium/disassembler.m"
41231       
41232 
41233               sprintf (str,  "ADCmrow", DIS_EADDR16, DIS_REG16);
41234 
41235       
41236 
41237       
41238       
41239       
41240     } 
41241     goto MATCH_finished_a; 
41242     
41243   MATCH_label_a384: (void)0; /*placeholder for label*/ 
41244     { 
41245       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41246       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41247       nextPC = 7 + MATCH_p; 
41248       
41249       #line 1183 "machine/pentium/disassembler.m"
41250       
41251 
41252               sprintf (str,  "ADCmrow", DIS_EADDR16, DIS_REG16);
41253 
41254       
41255 
41256       
41257       
41258       
41259     } 
41260     goto MATCH_finished_a; 
41261     
41262   MATCH_label_a385: (void)0; /*placeholder for label*/ 
41263     { 
41264       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41265       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41266       nextPC = 3 + MATCH_p; 
41267       
41268       #line 1177 "machine/pentium/disassembler.m"
41269       
41270 
41271               sprintf (str,  "SBBmrow", DIS_EADDR16, DIS_REG16);
41272 
41273       
41274 
41275       
41276       
41277       
41278     } 
41279     goto MATCH_finished_a; 
41280     
41281   MATCH_label_a386: (void)0; /*placeholder for label*/ 
41282     { 
41283       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41284       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41285       nextPC = 4 + MATCH_p; 
41286       
41287       #line 1177 "machine/pentium/disassembler.m"
41288       
41289 
41290               sprintf (str,  "SBBmrow", DIS_EADDR16, DIS_REG16);
41291 
41292       
41293 
41294       
41295       
41296       
41297     } 
41298     goto MATCH_finished_a; 
41299     
41300   MATCH_label_a387: (void)0; /*placeholder for label*/ 
41301     { 
41302       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41303       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41304       nextPC = 8 + MATCH_p; 
41305       
41306       #line 1177 "machine/pentium/disassembler.m"
41307       
41308 
41309               sprintf (str,  "SBBmrow", DIS_EADDR16, DIS_REG16);
41310 
41311       
41312 
41313       
41314       
41315       
41316     } 
41317     goto MATCH_finished_a; 
41318     
41319   MATCH_label_a388: (void)0; /*placeholder for label*/ 
41320     { 
41321       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41322       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41323       nextPC = 7 + MATCH_p; 
41324       
41325       #line 1177 "machine/pentium/disassembler.m"
41326       
41327 
41328               sprintf (str,  "SBBmrow", DIS_EADDR16, DIS_REG16);
41329 
41330       
41331 
41332       
41333       
41334       
41335     } 
41336     goto MATCH_finished_a; 
41337     
41338   MATCH_label_a389: (void)0; /*placeholder for label*/ 
41339     { 
41340       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41341       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41342       nextPC = 3 + MATCH_p; 
41343       
41344       #line 1111 "machine/pentium/disassembler.m"
41345       
41346 
41347               sprintf (str,  "ADCrmow", DIS_REG16, DIS_EADDR16);
41348 
41349       
41350 
41351       
41352       
41353       
41354     } 
41355     goto MATCH_finished_a; 
41356     
41357   MATCH_label_a390: (void)0; /*placeholder for label*/ 
41358     { 
41359       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41360       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41361       nextPC = 4 + MATCH_p; 
41362       
41363       #line 1111 "machine/pentium/disassembler.m"
41364       
41365 
41366               sprintf (str,  "ADCrmow", DIS_REG16, DIS_EADDR16);
41367 
41368       
41369 
41370       
41371       
41372       
41373     } 
41374     goto MATCH_finished_a; 
41375     
41376   MATCH_label_a391: (void)0; /*placeholder for label*/ 
41377     { 
41378       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41379       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41380       nextPC = 8 + MATCH_p; 
41381       
41382       #line 1111 "machine/pentium/disassembler.m"
41383       
41384 
41385               sprintf (str,  "ADCrmow", DIS_REG16, DIS_EADDR16);
41386 
41387       
41388 
41389       
41390       
41391       
41392     } 
41393     goto MATCH_finished_a; 
41394     
41395   MATCH_label_a392: (void)0; /*placeholder for label*/ 
41396     { 
41397       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41398       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41399       nextPC = 7 + MATCH_p; 
41400       
41401       #line 1111 "machine/pentium/disassembler.m"
41402       
41403 
41404               sprintf (str,  "ADCrmow", DIS_REG16, DIS_EADDR16);
41405 
41406       
41407 
41408       
41409       
41410       
41411     } 
41412     goto MATCH_finished_a; 
41413     
41414   MATCH_label_a393: (void)0; /*placeholder for label*/ 
41415     { 
41416       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41417       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41418       nextPC = 3 + MATCH_p; 
41419       
41420       #line 1105 "machine/pentium/disassembler.m"
41421       
41422 
41423               sprintf (str,  "SBBrmow", DIS_REG16, DIS_EADDR16);
41424 
41425       
41426 
41427       
41428       
41429       
41430     } 
41431     goto MATCH_finished_a; 
41432     
41433   MATCH_label_a394: (void)0; /*placeholder for label*/ 
41434     { 
41435       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41436       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41437       nextPC = 4 + MATCH_p; 
41438       
41439       #line 1105 "machine/pentium/disassembler.m"
41440       
41441 
41442               sprintf (str,  "SBBrmow", DIS_REG16, DIS_EADDR16);
41443 
41444       
41445 
41446       
41447       
41448       
41449     } 
41450     goto MATCH_finished_a; 
41451     
41452   MATCH_label_a395: (void)0; /*placeholder for label*/ 
41453     { 
41454       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41455       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41456       nextPC = 8 + MATCH_p; 
41457       
41458       #line 1105 "machine/pentium/disassembler.m"
41459       
41460 
41461               sprintf (str,  "SBBrmow", DIS_REG16, DIS_EADDR16);
41462 
41463       
41464 
41465       
41466       
41467       
41468     } 
41469     goto MATCH_finished_a; 
41470     
41471   MATCH_label_a396: (void)0; /*placeholder for label*/ 
41472     { 
41473       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41474       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41475       nextPC = 7 + MATCH_p; 
41476       
41477       #line 1105 "machine/pentium/disassembler.m"
41478       
41479 
41480               sprintf (str,  "SBBrmow", DIS_REG16, DIS_EADDR16);
41481 
41482       
41483 
41484       
41485       
41486       
41487     } 
41488     goto MATCH_finished_a; 
41489     
41490   MATCH_label_a397: (void)0; /*placeholder for label*/ 
41491     { 
41492       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41493       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41494       nextPC = 3 + MATCH_p; 
41495       
41496       #line 1171 "machine/pentium/disassembler.m"
41497       
41498 
41499               sprintf (str,  "ANDmrow", DIS_EADDR16, DIS_REG16);
41500 
41501       
41502 
41503       
41504       
41505       
41506     } 
41507     goto MATCH_finished_a; 
41508     
41509   MATCH_label_a398: (void)0; /*placeholder for label*/ 
41510     { 
41511       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41512       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41513       nextPC = 4 + MATCH_p; 
41514       
41515       #line 1171 "machine/pentium/disassembler.m"
41516       
41517 
41518               sprintf (str,  "ANDmrow", DIS_EADDR16, DIS_REG16);
41519 
41520       
41521 
41522       
41523       
41524       
41525     } 
41526     goto MATCH_finished_a; 
41527     
41528   MATCH_label_a399: (void)0; /*placeholder for label*/ 
41529     { 
41530       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41531       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41532       nextPC = 8 + MATCH_p; 
41533       
41534       #line 1171 "machine/pentium/disassembler.m"
41535       
41536 
41537               sprintf (str,  "ANDmrow", DIS_EADDR16, DIS_REG16);
41538 
41539       
41540 
41541       
41542       
41543       
41544     } 
41545     goto MATCH_finished_a; 
41546     
41547   MATCH_label_a400: (void)0; /*placeholder for label*/ 
41548     { 
41549       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41550       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41551       nextPC = 7 + MATCH_p; 
41552       
41553       #line 1171 "machine/pentium/disassembler.m"
41554       
41555 
41556               sprintf (str,  "ANDmrow", DIS_EADDR16, DIS_REG16);
41557 
41558       
41559 
41560       
41561       
41562       
41563     } 
41564     goto MATCH_finished_a; 
41565     
41566   MATCH_label_a401: (void)0; /*placeholder for label*/ 
41567     { 
41568       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41569       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41570       nextPC = 3 + MATCH_p; 
41571       
41572       #line 1165 "machine/pentium/disassembler.m"
41573       
41574 
41575               sprintf (str,  "SUBmrow", DIS_EADDR16, DIS_REG16);
41576 
41577       
41578 
41579       
41580       
41581       
41582     } 
41583     goto MATCH_finished_a; 
41584     
41585   MATCH_label_a402: (void)0; /*placeholder for label*/ 
41586     { 
41587       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41588       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41589       nextPC = 4 + MATCH_p; 
41590       
41591       #line 1165 "machine/pentium/disassembler.m"
41592       
41593 
41594               sprintf (str,  "SUBmrow", DIS_EADDR16, DIS_REG16);
41595 
41596       
41597 
41598       
41599       
41600       
41601     } 
41602     goto MATCH_finished_a; 
41603     
41604   MATCH_label_a403: (void)0; /*placeholder for label*/ 
41605     { 
41606       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41607       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41608       nextPC = 8 + MATCH_p; 
41609       
41610       #line 1165 "machine/pentium/disassembler.m"
41611       
41612 
41613               sprintf (str,  "SUBmrow", DIS_EADDR16, DIS_REG16);
41614 
41615       
41616 
41617       
41618       
41619       
41620     } 
41621     goto MATCH_finished_a; 
41622     
41623   MATCH_label_a404: (void)0; /*placeholder for label*/ 
41624     { 
41625       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41626       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41627       nextPC = 7 + MATCH_p; 
41628       
41629       #line 1165 "machine/pentium/disassembler.m"
41630       
41631 
41632               sprintf (str,  "SUBmrow", DIS_EADDR16, DIS_REG16);
41633 
41634       
41635 
41636       
41637       
41638       
41639     } 
41640     goto MATCH_finished_a; 
41641     
41642   MATCH_label_a405: (void)0; /*placeholder for label*/ 
41643     { 
41644       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41645       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41646       nextPC = 3 + MATCH_p; 
41647       
41648       #line 1099 "machine/pentium/disassembler.m"
41649       
41650 
41651               sprintf (str,  "ANDrmow", DIS_REG16, DIS_EADDR16);
41652 
41653       
41654 
41655       
41656       
41657       
41658     } 
41659     goto MATCH_finished_a; 
41660     
41661   MATCH_label_a406: (void)0; /*placeholder for label*/ 
41662     { 
41663       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41664       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41665       nextPC = 4 + MATCH_p; 
41666       
41667       #line 1099 "machine/pentium/disassembler.m"
41668       
41669 
41670               sprintf (str,  "ANDrmow", DIS_REG16, DIS_EADDR16);
41671 
41672       
41673 
41674       
41675       
41676       
41677     } 
41678     goto MATCH_finished_a; 
41679     
41680   MATCH_label_a407: (void)0; /*placeholder for label*/ 
41681     { 
41682       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41683       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41684       nextPC = 8 + MATCH_p; 
41685       
41686       #line 1099 "machine/pentium/disassembler.m"
41687       
41688 
41689               sprintf (str,  "ANDrmow", DIS_REG16, DIS_EADDR16);
41690 
41691       
41692 
41693       
41694       
41695       
41696     } 
41697     goto MATCH_finished_a; 
41698     
41699   MATCH_label_a408: (void)0; /*placeholder for label*/ 
41700     { 
41701       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41702       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41703       nextPC = 7 + MATCH_p; 
41704       
41705       #line 1099 "machine/pentium/disassembler.m"
41706       
41707 
41708               sprintf (str,  "ANDrmow", DIS_REG16, DIS_EADDR16);
41709 
41710       
41711 
41712       
41713       
41714       
41715     } 
41716     goto MATCH_finished_a; 
41717     
41718   MATCH_label_a409: (void)0; /*placeholder for label*/ 
41719     { 
41720       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41721       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41722       nextPC = 3 + MATCH_p; 
41723       
41724       #line 1093 "machine/pentium/disassembler.m"
41725       
41726 
41727               sprintf (str,  "SUBrmow", DIS_REG16, DIS_EADDR16);
41728 
41729       
41730 
41731       
41732       
41733       
41734     } 
41735     goto MATCH_finished_a; 
41736     
41737   MATCH_label_a410: (void)0; /*placeholder for label*/ 
41738     { 
41739       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41740       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41741       nextPC = 4 + MATCH_p; 
41742       
41743       #line 1093 "machine/pentium/disassembler.m"
41744       
41745 
41746               sprintf (str,  "SUBrmow", DIS_REG16, DIS_EADDR16);
41747 
41748       
41749 
41750       
41751       
41752       
41753     } 
41754     goto MATCH_finished_a; 
41755     
41756   MATCH_label_a411: (void)0; /*placeholder for label*/ 
41757     { 
41758       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41759       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41760       nextPC = 8 + MATCH_p; 
41761       
41762       #line 1093 "machine/pentium/disassembler.m"
41763       
41764 
41765               sprintf (str,  "SUBrmow", DIS_REG16, DIS_EADDR16);
41766 
41767       
41768 
41769       
41770       
41771       
41772     } 
41773     goto MATCH_finished_a; 
41774     
41775   MATCH_label_a412: (void)0; /*placeholder for label*/ 
41776     { 
41777       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41778       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41779       nextPC = 7 + MATCH_p; 
41780       
41781       #line 1093 "machine/pentium/disassembler.m"
41782       
41783 
41784               sprintf (str,  "SUBrmow", DIS_REG16, DIS_EADDR16);
41785 
41786       
41787 
41788       
41789       
41790       
41791     } 
41792     goto MATCH_finished_a; 
41793     
41794   MATCH_label_a413: (void)0; /*placeholder for label*/ 
41795     { 
41796       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41797       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41798       nextPC = 3 + MATCH_p; 
41799       
41800       #line 1159 "machine/pentium/disassembler.m"
41801       
41802 
41803               sprintf (str,  "XORmrow", DIS_EADDR16, DIS_REG16);
41804 
41805       
41806 
41807       
41808       
41809       
41810     } 
41811     goto MATCH_finished_a; 
41812     
41813   MATCH_label_a414: (void)0; /*placeholder for label*/ 
41814     { 
41815       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41816       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41817       nextPC = 4 + MATCH_p; 
41818       
41819       #line 1159 "machine/pentium/disassembler.m"
41820       
41821 
41822               sprintf (str,  "XORmrow", DIS_EADDR16, DIS_REG16);
41823 
41824       
41825 
41826       
41827       
41828       
41829     } 
41830     goto MATCH_finished_a; 
41831     
41832   MATCH_label_a415: (void)0; /*placeholder for label*/ 
41833     { 
41834       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41835       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41836       nextPC = 8 + MATCH_p; 
41837       
41838       #line 1159 "machine/pentium/disassembler.m"
41839       
41840 
41841               sprintf (str,  "XORmrow", DIS_EADDR16, DIS_REG16);
41842 
41843       
41844 
41845       
41846       
41847       
41848     } 
41849     goto MATCH_finished_a; 
41850     
41851   MATCH_label_a416: (void)0; /*placeholder for label*/ 
41852     { 
41853       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41854       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41855       nextPC = 7 + MATCH_p; 
41856       
41857       #line 1159 "machine/pentium/disassembler.m"
41858       
41859 
41860               sprintf (str,  "XORmrow", DIS_EADDR16, DIS_REG16);
41861 
41862       
41863 
41864       
41865       
41866       
41867     } 
41868     goto MATCH_finished_a; 
41869     
41870   MATCH_label_a417: (void)0; /*placeholder for label*/ 
41871     { 
41872       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41873       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41874       nextPC = 3 + MATCH_p; 
41875       
41876       #line 1153 "machine/pentium/disassembler.m"
41877       
41878 
41879               sprintf (str,  "CMPmrow", DIS_EADDR16, DIS_REG16);
41880 
41881       
41882 
41883       
41884       
41885       
41886     } 
41887     goto MATCH_finished_a; 
41888     
41889   MATCH_label_a418: (void)0; /*placeholder for label*/ 
41890     { 
41891       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41892       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41893       nextPC = 4 + MATCH_p; 
41894       
41895       #line 1153 "machine/pentium/disassembler.m"
41896       
41897 
41898               sprintf (str,  "CMPmrow", DIS_EADDR16, DIS_REG16);
41899 
41900       
41901 
41902       
41903       
41904       
41905     } 
41906     goto MATCH_finished_a; 
41907     
41908   MATCH_label_a419: (void)0; /*placeholder for label*/ 
41909     { 
41910       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41911       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41912       nextPC = 8 + MATCH_p; 
41913       
41914       #line 1153 "machine/pentium/disassembler.m"
41915       
41916 
41917               sprintf (str,  "CMPmrow", DIS_EADDR16, DIS_REG16);
41918 
41919       
41920 
41921       
41922       
41923       
41924     } 
41925     goto MATCH_finished_a; 
41926     
41927   MATCH_label_a420: (void)0; /*placeholder for label*/ 
41928     { 
41929       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41930       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41931       nextPC = 7 + MATCH_p; 
41932       
41933       #line 1153 "machine/pentium/disassembler.m"
41934       
41935 
41936               sprintf (str,  "CMPmrow", DIS_EADDR16, DIS_REG16);
41937 
41938       
41939 
41940       
41941       
41942       
41943     } 
41944     goto MATCH_finished_a; 
41945     
41946   MATCH_label_a421: (void)0; /*placeholder for label*/ 
41947     { 
41948       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41949       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41950       nextPC = 3 + MATCH_p; 
41951       
41952       #line 1087 "machine/pentium/disassembler.m"
41953       
41954 
41955               sprintf (str,  "XORrmow", DIS_REG16, DIS_EADDR16);
41956 
41957       
41958 
41959       
41960       
41961       
41962     } 
41963     goto MATCH_finished_a; 
41964     
41965   MATCH_label_a422: (void)0; /*placeholder for label*/ 
41966     { 
41967       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41968       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41969       nextPC = 4 + MATCH_p; 
41970       
41971       #line 1087 "machine/pentium/disassembler.m"
41972       
41973 
41974               sprintf (str,  "XORrmow", DIS_REG16, DIS_EADDR16);
41975 
41976       
41977 
41978       
41979       
41980       
41981     } 
41982     goto MATCH_finished_a; 
41983     
41984   MATCH_label_a423: (void)0; /*placeholder for label*/ 
41985     { 
41986       unsigned Eaddr = 2 + addressToPC(MATCH_p);
41987       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
41988       nextPC = 8 + MATCH_p; 
41989       
41990       #line 1087 "machine/pentium/disassembler.m"
41991       
41992 
41993               sprintf (str,  "XORrmow", DIS_REG16, DIS_EADDR16);
41994 
41995       
41996 
41997       
41998       
41999       
42000     } 
42001     goto MATCH_finished_a; 
42002     
42003   MATCH_label_a424: (void)0; /*placeholder for label*/ 
42004     { 
42005       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42006       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42007       nextPC = 7 + MATCH_p; 
42008       
42009       #line 1087 "machine/pentium/disassembler.m"
42010       
42011 
42012               sprintf (str,  "XORrmow", DIS_REG16, DIS_EADDR16);
42013 
42014       
42015 
42016       
42017       
42018       
42019     } 
42020     goto MATCH_finished_a; 
42021     
42022   MATCH_label_a425: (void)0; /*placeholder for label*/ 
42023     { 
42024       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42025       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42026       nextPC = 3 + MATCH_p; 
42027       
42028       #line 1081 "machine/pentium/disassembler.m"
42029       
42030 
42031               sprintf (str,  "CMPrmow", DIS_REG16, DIS_EADDR16);
42032 
42033       
42034 
42035       
42036       
42037       
42038     } 
42039     goto MATCH_finished_a; 
42040     
42041   MATCH_label_a426: (void)0; /*placeholder for label*/ 
42042     { 
42043       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42044       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42045       nextPC = 4 + MATCH_p; 
42046       
42047       #line 1081 "machine/pentium/disassembler.m"
42048       
42049 
42050               sprintf (str,  "CMPrmow", DIS_REG16, DIS_EADDR16);
42051 
42052       
42053 
42054       
42055       
42056       
42057     } 
42058     goto MATCH_finished_a; 
42059     
42060   MATCH_label_a427: (void)0; /*placeholder for label*/ 
42061     { 
42062       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42063       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42064       nextPC = 8 + MATCH_p; 
42065       
42066       #line 1081 "machine/pentium/disassembler.m"
42067       
42068 
42069               sprintf (str,  "CMPrmow", DIS_REG16, DIS_EADDR16);
42070 
42071       
42072 
42073       
42074       
42075       
42076     } 
42077     goto MATCH_finished_a; 
42078     
42079   MATCH_label_a428: (void)0; /*placeholder for label*/ 
42080     { 
42081       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42082       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42083       nextPC = 7 + MATCH_p; 
42084       
42085       #line 1081 "machine/pentium/disassembler.m"
42086       
42087 
42088               sprintf (str,  "CMPrmow", DIS_REG16, DIS_EADDR16);
42089 
42090       
42091 
42092       
42093       
42094       
42095     } 
42096     goto MATCH_finished_a; 
42097     
42098   MATCH_label_a429: (void)0; /*placeholder for label*/ 
42099     { 
42100       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42101       int /* [~32768..32767] */ i16 = 
42102         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
42103       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42104       nextPC = 5 + MATCH_p; 
42105       
42106       #line 860 "machine/pentium/disassembler.m"
42107       
42108 
42109               sprintf (str,  "IMUL.Ivw", DIS_REG16, DIS_EADDR16, DIS_I16);
42110 
42111       
42112 
42113       
42114       
42115       
42116     } 
42117     goto MATCH_finished_a; 
42118     
42119   MATCH_label_a430: (void)0; /*placeholder for label*/ 
42120     { 
42121       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42122       int /* [~32768..32767] */ i16 = 
42123         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
42124       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42125       nextPC = 6 + MATCH_p; 
42126       
42127       #line 860 "machine/pentium/disassembler.m"
42128       
42129 
42130               sprintf (str,  "IMUL.Ivw", DIS_REG16, DIS_EADDR16, DIS_I16);
42131 
42132       
42133 
42134       
42135       
42136       
42137     } 
42138     goto MATCH_finished_a; 
42139     
42140   MATCH_label_a431: (void)0; /*placeholder for label*/ 
42141     { 
42142       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42143       int /* [~32768..32767] */ i16 = 
42144         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
42145       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42146       nextPC = 10 + MATCH_p; 
42147       
42148       #line 860 "machine/pentium/disassembler.m"
42149       
42150 
42151               sprintf (str,  "IMUL.Ivw", DIS_REG16, DIS_EADDR16, DIS_I16);
42152 
42153       
42154 
42155       
42156       
42157       
42158     } 
42159     goto MATCH_finished_a; 
42160     
42161   MATCH_label_a432: (void)0; /*placeholder for label*/ 
42162     { 
42163       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42164       int /* [~32768..32767] */ i16 = 
42165         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
42166       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42167       nextPC = 9 + MATCH_p; 
42168       
42169       #line 860 "machine/pentium/disassembler.m"
42170       
42171 
42172               sprintf (str,  "IMUL.Ivw", DIS_REG16, DIS_EADDR16, DIS_I16);
42173 
42174       
42175 
42176       
42177       
42178       
42179     } 
42180     goto MATCH_finished_a; 
42181     
42182   MATCH_label_a433: (void)0; /*placeholder for label*/ 
42183     { 
42184       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42185       int /* [~128..127] */ i8 = 
42186         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
42187       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42188       nextPC = 4 + MATCH_p; 
42189       
42190       #line 866 "machine/pentium/disassembler.m"
42191       
42192 
42193               sprintf (str,  "IMUL.Ibow", DIS_REG16, DIS_EADDR16, DIS_I8);
42194 
42195       
42196 
42197       
42198       
42199       
42200     } 
42201     goto MATCH_finished_a; 
42202     
42203   MATCH_label_a434: (void)0; /*placeholder for label*/ 
42204     { 
42205       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42206       int /* [~128..127] */ i8 = 
42207         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
42208       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42209       nextPC = 5 + MATCH_p; 
42210       
42211       #line 866 "machine/pentium/disassembler.m"
42212       
42213 
42214               sprintf (str,  "IMUL.Ibow", DIS_REG16, DIS_EADDR16, DIS_I8);
42215 
42216       
42217 
42218       
42219       
42220       
42221     } 
42222     goto MATCH_finished_a; 
42223     
42224   MATCH_label_a435: (void)0; /*placeholder for label*/ 
42225     { 
42226       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42227       int /* [~128..127] */ i8 = 
42228         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
42229       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42230       nextPC = 9 + MATCH_p; 
42231       
42232       #line 866 "machine/pentium/disassembler.m"
42233       
42234 
42235               sprintf (str,  "IMUL.Ibow", DIS_REG16, DIS_EADDR16, DIS_I8);
42236 
42237       
42238 
42239       
42240       
42241       
42242     } 
42243     goto MATCH_finished_a; 
42244     
42245   MATCH_label_a436: (void)0; /*placeholder for label*/ 
42246     { 
42247       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42248       int /* [~128..127] */ i8 = 
42249         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
42250       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42251       nextPC = 8 + MATCH_p; 
42252       
42253       #line 866 "machine/pentium/disassembler.m"
42254       
42255 
42256               sprintf (str,  "IMUL.Ibow", DIS_REG16, DIS_EADDR16, DIS_I8);
42257 
42258       
42259 
42260       
42261       
42262       
42263     } 
42264     goto MATCH_finished_a; 
42265     
42266   MATCH_label_a437: (void)0; /*placeholder for label*/ 
42267     { 
42268       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42269       int /* [~32768..32767] */ i16 = 
42270         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
42271       nextPC = 5 + MATCH_p; 
42272       
42273       #line 1315 "machine/pentium/disassembler.m"
42274       
42275 
42276               sprintf (str,  "ADDiw", DIS_EADDR16, DIS_I16);
42277 
42278       
42279 
42280       
42281       
42282       
42283     } 
42284     goto MATCH_finished_a; 
42285     
42286   MATCH_label_a438: (void)0; /*placeholder for label*/ 
42287     { 
42288       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42289       int /* [~32768..32767] */ i16 = 
42290         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
42291       nextPC = 6 + MATCH_p; 
42292       
42293       #line 1315 "machine/pentium/disassembler.m"
42294       
42295 
42296               sprintf (str,  "ADDiw", DIS_EADDR16, DIS_I16);
42297 
42298       
42299 
42300       
42301       
42302       
42303     } 
42304     goto MATCH_finished_a; 
42305     
42306   MATCH_label_a439: (void)0; /*placeholder for label*/ 
42307     { 
42308       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42309       int /* [~32768..32767] */ i16 = 
42310         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
42311       nextPC = 10 + MATCH_p; 
42312       
42313       #line 1315 "machine/pentium/disassembler.m"
42314       
42315 
42316               sprintf (str,  "ADDiw", DIS_EADDR16, DIS_I16);
42317 
42318       
42319 
42320       
42321       
42322       
42323     } 
42324     goto MATCH_finished_a; 
42325     
42326   MATCH_label_a440: (void)0; /*placeholder for label*/ 
42327     { 
42328       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42329       int /* [~32768..32767] */ i16 = 
42330         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
42331       nextPC = 9 + MATCH_p; 
42332       
42333       #line 1315 "machine/pentium/disassembler.m"
42334       
42335 
42336               sprintf (str,  "ADDiw", DIS_EADDR16, DIS_I16);
42337 
42338       
42339 
42340       
42341       
42342       
42343     } 
42344     goto MATCH_finished_a; 
42345     
42346   MATCH_label_a441: (void)0; /*placeholder for label*/ 
42347     { 
42348       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42349       int /* [~32768..32767] */ i16 = 
42350         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
42351       nextPC = 5 + MATCH_p; 
42352       
42353       #line 1312 "machine/pentium/disassembler.m"
42354       
42355 
42356               sprintf (str,  "ORiw", DIS_EADDR16, DIS_I16);
42357 
42358       
42359 
42360       
42361       
42362       
42363     } 
42364     goto MATCH_finished_a; 
42365     
42366   MATCH_label_a442: (void)0; /*placeholder for label*/ 
42367     { 
42368       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42369       int /* [~32768..32767] */ i16 = 
42370         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
42371       nextPC = 6 + MATCH_p; 
42372       
42373       #line 1312 "machine/pentium/disassembler.m"
42374       
42375 
42376               sprintf (str,  "ORiw", DIS_EADDR16, DIS_I16);
42377 
42378       
42379 
42380       
42381       
42382       
42383     } 
42384     goto MATCH_finished_a; 
42385     
42386   MATCH_label_a443: (void)0; /*placeholder for label*/ 
42387     { 
42388       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42389       int /* [~32768..32767] */ i16 = 
42390         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
42391       nextPC = 10 + MATCH_p; 
42392       
42393       #line 1312 "machine/pentium/disassembler.m"
42394       
42395 
42396               sprintf (str,  "ORiw", DIS_EADDR16, DIS_I16);
42397 
42398       
42399 
42400       
42401       
42402       
42403     } 
42404     goto MATCH_finished_a; 
42405     
42406   MATCH_label_a444: (void)0; /*placeholder for label*/ 
42407     { 
42408       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42409       int /* [~32768..32767] */ i16 = 
42410         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
42411       nextPC = 9 + MATCH_p; 
42412       
42413       #line 1312 "machine/pentium/disassembler.m"
42414       
42415 
42416               sprintf (str,  "ORiw", DIS_EADDR16, DIS_I16);
42417 
42418       
42419 
42420       
42421       
42422       
42423     } 
42424     goto MATCH_finished_a; 
42425     
42426   MATCH_label_a445: (void)0; /*placeholder for label*/ 
42427     { 
42428       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42429       int /* [~32768..32767] */ i16 = 
42430         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
42431       nextPC = 5 + MATCH_p; 
42432       
42433       #line 1309 "machine/pentium/disassembler.m"
42434       
42435 
42436               sprintf (str,  "ADCiw", DIS_EADDR16, DIS_I16);
42437 
42438       
42439 
42440       
42441       
42442       
42443     } 
42444     goto MATCH_finished_a; 
42445     
42446   MATCH_label_a446: (void)0; /*placeholder for label*/ 
42447     { 
42448       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42449       int /* [~32768..32767] */ i16 = 
42450         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
42451       nextPC = 6 + MATCH_p; 
42452       
42453       #line 1309 "machine/pentium/disassembler.m"
42454       
42455 
42456               sprintf (str,  "ADCiw", DIS_EADDR16, DIS_I16);
42457 
42458       
42459 
42460       
42461       
42462       
42463     } 
42464     goto MATCH_finished_a; 
42465     
42466   MATCH_label_a447: (void)0; /*placeholder for label*/ 
42467     { 
42468       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42469       int /* [~32768..32767] */ i16 = 
42470         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
42471       nextPC = 10 + MATCH_p; 
42472       
42473       #line 1309 "machine/pentium/disassembler.m"
42474       
42475 
42476               sprintf (str,  "ADCiw", DIS_EADDR16, DIS_I16);
42477 
42478       
42479 
42480       
42481       
42482       
42483     } 
42484     goto MATCH_finished_a; 
42485     
42486   MATCH_label_a448: (void)0; /*placeholder for label*/ 
42487     { 
42488       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42489       int /* [~32768..32767] */ i16 = 
42490         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
42491       nextPC = 9 + MATCH_p; 
42492       
42493       #line 1309 "machine/pentium/disassembler.m"
42494       
42495 
42496               sprintf (str,  "ADCiw", DIS_EADDR16, DIS_I16);
42497 
42498       
42499 
42500       
42501       
42502       
42503     } 
42504     goto MATCH_finished_a; 
42505     
42506   MATCH_label_a449: (void)0; /*placeholder for label*/ 
42507     { 
42508       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42509       int /* [~32768..32767] */ i16 = 
42510         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
42511       nextPC = 5 + MATCH_p; 
42512       
42513       #line 1306 "machine/pentium/disassembler.m"
42514       
42515 
42516               sprintf (str,  "SBBiw", DIS_EADDR16, DIS_I16);
42517 
42518       
42519 
42520       
42521       
42522       
42523     } 
42524     goto MATCH_finished_a; 
42525     
42526   MATCH_label_a450: (void)0; /*placeholder for label*/ 
42527     { 
42528       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42529       int /* [~32768..32767] */ i16 = 
42530         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
42531       nextPC = 6 + MATCH_p; 
42532       
42533       #line 1306 "machine/pentium/disassembler.m"
42534       
42535 
42536               sprintf (str,  "SBBiw", DIS_EADDR16, DIS_I16);
42537 
42538       
42539 
42540       
42541       
42542       
42543     } 
42544     goto MATCH_finished_a; 
42545     
42546   MATCH_label_a451: (void)0; /*placeholder for label*/ 
42547     { 
42548       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42549       int /* [~32768..32767] */ i16 = 
42550         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
42551       nextPC = 10 + MATCH_p; 
42552       
42553       #line 1306 "machine/pentium/disassembler.m"
42554       
42555 
42556               sprintf (str,  "SBBiw", DIS_EADDR16, DIS_I16);
42557 
42558       
42559 
42560       
42561       
42562       
42563     } 
42564     goto MATCH_finished_a; 
42565     
42566   MATCH_label_a452: (void)0; /*placeholder for label*/ 
42567     { 
42568       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42569       int /* [~32768..32767] */ i16 = 
42570         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
42571       nextPC = 9 + MATCH_p; 
42572       
42573       #line 1306 "machine/pentium/disassembler.m"
42574       
42575 
42576               sprintf (str,  "SBBiw", DIS_EADDR16, DIS_I16);
42577 
42578       
42579 
42580       
42581       
42582       
42583     } 
42584     goto MATCH_finished_a; 
42585     
42586   MATCH_label_a453: (void)0; /*placeholder for label*/ 
42587     { 
42588       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42589       int /* [~32768..32767] */ i16 = 
42590         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
42591       nextPC = 5 + MATCH_p; 
42592       
42593       #line 1303 "machine/pentium/disassembler.m"
42594       
42595 
42596               sprintf (str,  "ANDiw", DIS_EADDR16, DIS_I16);
42597 
42598       
42599 
42600       
42601       
42602       
42603     } 
42604     goto MATCH_finished_a; 
42605     
42606   MATCH_label_a454: (void)0; /*placeholder for label*/ 
42607     { 
42608       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42609       int /* [~32768..32767] */ i16 = 
42610         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
42611       nextPC = 6 + MATCH_p; 
42612       
42613       #line 1303 "machine/pentium/disassembler.m"
42614       
42615 
42616               sprintf (str,  "ANDiw", DIS_EADDR16, DIS_I16);
42617 
42618       
42619 
42620       
42621       
42622       
42623     } 
42624     goto MATCH_finished_a; 
42625     
42626   MATCH_label_a455: (void)0; /*placeholder for label*/ 
42627     { 
42628       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42629       int /* [~32768..32767] */ i16 = 
42630         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
42631       nextPC = 10 + MATCH_p; 
42632       
42633       #line 1303 "machine/pentium/disassembler.m"
42634       
42635 
42636               sprintf (str,  "ANDiw", DIS_EADDR16, DIS_I16);
42637 
42638       
42639 
42640       
42641       
42642       
42643     } 
42644     goto MATCH_finished_a; 
42645     
42646   MATCH_label_a456: (void)0; /*placeholder for label*/ 
42647     { 
42648       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42649       int /* [~32768..32767] */ i16 = 
42650         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
42651       nextPC = 9 + MATCH_p; 
42652       
42653       #line 1303 "machine/pentium/disassembler.m"
42654       
42655 
42656               sprintf (str,  "ANDiw", DIS_EADDR16, DIS_I16);
42657 
42658       
42659 
42660       
42661       
42662       
42663     } 
42664     goto MATCH_finished_a; 
42665     
42666   MATCH_label_a457: (void)0; /*placeholder for label*/ 
42667     { 
42668       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42669       int /* [~32768..32767] */ i16 = 
42670         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
42671       nextPC = 5 + MATCH_p; 
42672       
42673       #line 1300 "machine/pentium/disassembler.m"
42674       
42675 
42676               sprintf (str,  "SUBiw", DIS_EADDR16, DIS_I16);
42677 
42678       
42679 
42680       
42681       
42682       
42683     } 
42684     goto MATCH_finished_a; 
42685     
42686   MATCH_label_a458: (void)0; /*placeholder for label*/ 
42687     { 
42688       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42689       int /* [~32768..32767] */ i16 = 
42690         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
42691       nextPC = 6 + MATCH_p; 
42692       
42693       #line 1300 "machine/pentium/disassembler.m"
42694       
42695 
42696               sprintf (str,  "SUBiw", DIS_EADDR16, DIS_I16);
42697 
42698       
42699 
42700       
42701       
42702       
42703     } 
42704     goto MATCH_finished_a; 
42705     
42706   MATCH_label_a459: (void)0; /*placeholder for label*/ 
42707     { 
42708       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42709       int /* [~32768..32767] */ i16 = 
42710         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
42711       nextPC = 10 + MATCH_p; 
42712       
42713       #line 1300 "machine/pentium/disassembler.m"
42714       
42715 
42716               sprintf (str,  "SUBiw", DIS_EADDR16, DIS_I16);
42717 
42718       
42719 
42720       
42721       
42722       
42723     } 
42724     goto MATCH_finished_a; 
42725     
42726   MATCH_label_a460: (void)0; /*placeholder for label*/ 
42727     { 
42728       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42729       int /* [~32768..32767] */ i16 = 
42730         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
42731       nextPC = 9 + MATCH_p; 
42732       
42733       #line 1300 "machine/pentium/disassembler.m"
42734       
42735 
42736               sprintf (str,  "SUBiw", DIS_EADDR16, DIS_I16);
42737 
42738       
42739 
42740       
42741       
42742       
42743     } 
42744     goto MATCH_finished_a; 
42745     
42746   MATCH_label_a461: (void)0; /*placeholder for label*/ 
42747     { 
42748       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42749       int /* [~32768..32767] */ i16 = 
42750         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
42751       nextPC = 5 + MATCH_p; 
42752       
42753       #line 1297 "machine/pentium/disassembler.m"
42754       
42755 
42756               sprintf (str,  "XORiw", DIS_EADDR16, DIS_I16);
42757 
42758       
42759 
42760       
42761       
42762       
42763     } 
42764     goto MATCH_finished_a; 
42765     
42766   MATCH_label_a462: (void)0; /*placeholder for label*/ 
42767     { 
42768       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42769       int /* [~32768..32767] */ i16 = 
42770         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
42771       nextPC = 6 + MATCH_p; 
42772       
42773       #line 1297 "machine/pentium/disassembler.m"
42774       
42775 
42776               sprintf (str,  "XORiw", DIS_EADDR16, DIS_I16);
42777 
42778       
42779 
42780       
42781       
42782       
42783     } 
42784     goto MATCH_finished_a; 
42785     
42786   MATCH_label_a463: (void)0; /*placeholder for label*/ 
42787     { 
42788       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42789       int /* [~32768..32767] */ i16 = 
42790         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
42791       nextPC = 10 + MATCH_p; 
42792       
42793       #line 1297 "machine/pentium/disassembler.m"
42794       
42795 
42796               sprintf (str,  "XORiw", DIS_EADDR16, DIS_I16);
42797 
42798       
42799 
42800       
42801       
42802       
42803     } 
42804     goto MATCH_finished_a; 
42805     
42806   MATCH_label_a464: (void)0; /*placeholder for label*/ 
42807     { 
42808       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42809       int /* [~32768..32767] */ i16 = 
42810         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
42811       nextPC = 9 + MATCH_p; 
42812       
42813       #line 1297 "machine/pentium/disassembler.m"
42814       
42815 
42816               sprintf (str,  "XORiw", DIS_EADDR16, DIS_I16);
42817 
42818       
42819 
42820       
42821       
42822       
42823     } 
42824     goto MATCH_finished_a; 
42825     
42826   MATCH_label_a465: (void)0; /*placeholder for label*/ 
42827     { 
42828       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42829       int /* [~32768..32767] */ i16 = 
42830         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
42831       nextPC = 5 + MATCH_p; 
42832       
42833       #line 1294 "machine/pentium/disassembler.m"
42834       
42835 
42836               sprintf (str,  "CMPiw", DIS_EADDR16, DIS_I16);
42837 
42838       
42839 
42840       
42841       
42842       
42843     } 
42844     goto MATCH_finished_a; 
42845     
42846   MATCH_label_a466: (void)0; /*placeholder for label*/ 
42847     { 
42848       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42849       int /* [~32768..32767] */ i16 = 
42850         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
42851       nextPC = 6 + MATCH_p; 
42852       
42853       #line 1294 "machine/pentium/disassembler.m"
42854       
42855 
42856               sprintf (str,  "CMPiw", DIS_EADDR16, DIS_I16);
42857 
42858       
42859 
42860       
42861       
42862       
42863     } 
42864     goto MATCH_finished_a; 
42865     
42866   MATCH_label_a467: (void)0; /*placeholder for label*/ 
42867     { 
42868       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42869       int /* [~32768..32767] */ i16 = 
42870         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
42871       nextPC = 10 + MATCH_p; 
42872       
42873       #line 1294 "machine/pentium/disassembler.m"
42874       
42875 
42876               sprintf (str,  "CMPiw", DIS_EADDR16, DIS_I16);
42877 
42878       
42879 
42880       
42881       
42882       
42883     } 
42884     goto MATCH_finished_a; 
42885     
42886   MATCH_label_a468: (void)0; /*placeholder for label*/ 
42887     { 
42888       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42889       int /* [~32768..32767] */ i16 = 
42890         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
42891       nextPC = 9 + MATCH_p; 
42892       
42893       #line 1294 "machine/pentium/disassembler.m"
42894       
42895 
42896               sprintf (str,  "CMPiw", DIS_EADDR16, DIS_I16);
42897 
42898       
42899 
42900       
42901       
42902       
42903     } 
42904     goto MATCH_finished_a; 
42905     
42906   MATCH_label_a469: (void)0; /*placeholder for label*/ 
42907     { 
42908       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42909       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42910       nextPC = 3 + MATCH_p; 
42911       
42912       #line 739 "machine/pentium/disassembler.m"
42913       
42914 
42915               sprintf (str,  "MOVmrow", DIS_EADDR16, DIS_REG16);
42916 
42917       
42918 
42919       
42920       
42921       
42922     } 
42923     goto MATCH_finished_a; 
42924     
42925   MATCH_label_a470: (void)0; /*placeholder for label*/ 
42926     { 
42927       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42928       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42929       nextPC = 4 + MATCH_p; 
42930       
42931       #line 739 "machine/pentium/disassembler.m"
42932       
42933 
42934               sprintf (str,  "MOVmrow", DIS_EADDR16, DIS_REG16);
42935 
42936       
42937 
42938       
42939       
42940       
42941     } 
42942     goto MATCH_finished_a; 
42943     
42944   MATCH_label_a471: (void)0; /*placeholder for label*/ 
42945     { 
42946       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42947       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42948       nextPC = 8 + MATCH_p; 
42949       
42950       #line 739 "machine/pentium/disassembler.m"
42951       
42952 
42953               sprintf (str,  "MOVmrow", DIS_EADDR16, DIS_REG16);
42954 
42955       
42956 
42957       
42958       
42959       
42960     } 
42961     goto MATCH_finished_a; 
42962     
42963   MATCH_label_a472: (void)0; /*placeholder for label*/ 
42964     { 
42965       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42966       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
42967       nextPC = 7 + MATCH_p; 
42968       
42969       #line 739 "machine/pentium/disassembler.m"
42970       
42971 
42972               sprintf (str,  "MOVmrow", DIS_EADDR16, DIS_REG16);
42973 
42974       
42975 
42976       
42977       
42978       
42979     } 
42980     goto MATCH_finished_a; 
42981     
42982   MATCH_label_a473: (void)0; /*placeholder for label*/ 
42983     { 
42984       unsigned Eaddr = 2 + addressToPC(MATCH_p);
42985       int /* [~128..127] */ i8 = 
42986         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
42987       nextPC = 4 + MATCH_p; 
42988       
42989       #line 1267 "machine/pentium/disassembler.m"
42990       
42991 
42992               sprintf (str,  "ADDiowb", DIS_EADDR16, DIS_I8);
42993 
42994       
42995 
42996       
42997       
42998       
42999     } 
43000     goto MATCH_finished_a; 
43001     
43002   MATCH_label_a474: (void)0; /*placeholder for label*/ 
43003     { 
43004       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43005       int /* [~128..127] */ i8 = 
43006         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
43007       nextPC = 5 + MATCH_p; 
43008       
43009       #line 1267 "machine/pentium/disassembler.m"
43010       
43011 
43012               sprintf (str,  "ADDiowb", DIS_EADDR16, DIS_I8);
43013 
43014       
43015 
43016       
43017       
43018       
43019     } 
43020     goto MATCH_finished_a; 
43021     
43022   MATCH_label_a475: (void)0; /*placeholder for label*/ 
43023     { 
43024       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43025       int /* [~128..127] */ i8 = 
43026         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
43027       nextPC = 9 + MATCH_p; 
43028       
43029       #line 1267 "machine/pentium/disassembler.m"
43030       
43031 
43032               sprintf (str,  "ADDiowb", DIS_EADDR16, DIS_I8);
43033 
43034       
43035 
43036       
43037       
43038       
43039     } 
43040     goto MATCH_finished_a; 
43041     
43042   MATCH_label_a476: (void)0; /*placeholder for label*/ 
43043     { 
43044       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43045       int /* [~128..127] */ i8 = 
43046         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
43047       nextPC = 8 + MATCH_p; 
43048       
43049       #line 1267 "machine/pentium/disassembler.m"
43050       
43051 
43052               sprintf (str,  "ADDiowb", DIS_EADDR16, DIS_I8);
43053 
43054       
43055 
43056       
43057       
43058       
43059     } 
43060     goto MATCH_finished_a; 
43061     
43062   MATCH_label_a477: (void)0; /*placeholder for label*/ 
43063     { 
43064       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43065       int /* [~128..127] */ i8 = 
43066         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
43067       nextPC = 4 + MATCH_p; 
43068       
43069       #line 1261 "machine/pentium/disassembler.m"
43070       
43071 
43072               sprintf (str,  "ORiowb", DIS_EADDR16, DIS_I8);
43073 
43074       
43075 
43076       
43077       
43078       
43079     } 
43080     goto MATCH_finished_a; 
43081     
43082   MATCH_label_a478: (void)0; /*placeholder for label*/ 
43083     { 
43084       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43085       int /* [~128..127] */ i8 = 
43086         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
43087       nextPC = 5 + MATCH_p; 
43088       
43089       #line 1261 "machine/pentium/disassembler.m"
43090       
43091 
43092               sprintf (str,  "ORiowb", DIS_EADDR16, DIS_I8);
43093 
43094       
43095 
43096       
43097       
43098       
43099     } 
43100     goto MATCH_finished_a; 
43101     
43102   MATCH_label_a479: (void)0; /*placeholder for label*/ 
43103     { 
43104       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43105       int /* [~128..127] */ i8 = 
43106         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
43107       nextPC = 9 + MATCH_p; 
43108       
43109       #line 1261 "machine/pentium/disassembler.m"
43110       
43111 
43112               sprintf (str,  "ORiowb", DIS_EADDR16, DIS_I8);
43113 
43114       
43115 
43116       
43117       
43118       
43119     } 
43120     goto MATCH_finished_a; 
43121     
43122   MATCH_label_a480: (void)0; /*placeholder for label*/ 
43123     { 
43124       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43125       int /* [~128..127] */ i8 = 
43126         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
43127       nextPC = 8 + MATCH_p; 
43128       
43129       #line 1261 "machine/pentium/disassembler.m"
43130       
43131 
43132               sprintf (str,  "ORiowb", DIS_EADDR16, DIS_I8);
43133 
43134       
43135 
43136       
43137       
43138       
43139     } 
43140     goto MATCH_finished_a; 
43141     
43142   MATCH_label_a481: (void)0; /*placeholder for label*/ 
43143     { 
43144       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43145       int /* [~128..127] */ i8 = 
43146         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
43147       nextPC = 4 + MATCH_p; 
43148       
43149       #line 1255 "machine/pentium/disassembler.m"
43150       
43151 
43152               sprintf (str,  "ADCiowb", DIS_EADDR16, DIS_I8);
43153 
43154       
43155 
43156       
43157       
43158       
43159     } 
43160     goto MATCH_finished_a; 
43161     
43162   MATCH_label_a482: (void)0; /*placeholder for label*/ 
43163     { 
43164       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43165       int /* [~128..127] */ i8 = 
43166         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
43167       nextPC = 5 + MATCH_p; 
43168       
43169       #line 1255 "machine/pentium/disassembler.m"
43170       
43171 
43172               sprintf (str,  "ADCiowb", DIS_EADDR16, DIS_I8);
43173 
43174       
43175 
43176       
43177       
43178       
43179     } 
43180     goto MATCH_finished_a; 
43181     
43182   MATCH_label_a483: (void)0; /*placeholder for label*/ 
43183     { 
43184       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43185       int /* [~128..127] */ i8 = 
43186         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
43187       nextPC = 9 + MATCH_p; 
43188       
43189       #line 1255 "machine/pentium/disassembler.m"
43190       
43191 
43192               sprintf (str,  "ADCiowb", DIS_EADDR16, DIS_I8);
43193 
43194       
43195 
43196       
43197       
43198       
43199     } 
43200     goto MATCH_finished_a; 
43201     
43202   MATCH_label_a484: (void)0; /*placeholder for label*/ 
43203     { 
43204       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43205       int /* [~128..127] */ i8 = 
43206         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
43207       nextPC = 8 + MATCH_p; 
43208       
43209       #line 1255 "machine/pentium/disassembler.m"
43210       
43211 
43212               sprintf (str,  "ADCiowb", DIS_EADDR16, DIS_I8);
43213 
43214       
43215 
43216       
43217       
43218       
43219     } 
43220     goto MATCH_finished_a; 
43221     
43222   MATCH_label_a485: (void)0; /*placeholder for label*/ 
43223     { 
43224       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43225       int /* [~128..127] */ i8 = 
43226         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
43227       nextPC = 4 + MATCH_p; 
43228       
43229       #line 1249 "machine/pentium/disassembler.m"
43230       
43231 
43232               sprintf (str,  "SBBiowb", DIS_EADDR16, DIS_I8);
43233 
43234       
43235 
43236       
43237       
43238       
43239     } 
43240     goto MATCH_finished_a; 
43241     
43242   MATCH_label_a486: (void)0; /*placeholder for label*/ 
43243     { 
43244       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43245       int /* [~128..127] */ i8 = 
43246         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
43247       nextPC = 5 + MATCH_p; 
43248       
43249       #line 1249 "machine/pentium/disassembler.m"
43250       
43251 
43252               sprintf (str,  "SBBiowb", DIS_EADDR16, DIS_I8);
43253 
43254       
43255 
43256       
43257       
43258       
43259     } 
43260     goto MATCH_finished_a; 
43261     
43262   MATCH_label_a487: (void)0; /*placeholder for label*/ 
43263     { 
43264       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43265       int /* [~128..127] */ i8 = 
43266         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
43267       nextPC = 9 + MATCH_p; 
43268       
43269       #line 1249 "machine/pentium/disassembler.m"
43270       
43271 
43272               sprintf (str,  "SBBiowb", DIS_EADDR16, DIS_I8);
43273 
43274       
43275 
43276       
43277       
43278       
43279     } 
43280     goto MATCH_finished_a; 
43281     
43282   MATCH_label_a488: (void)0; /*placeholder for label*/ 
43283     { 
43284       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43285       int /* [~128..127] */ i8 = 
43286         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
43287       nextPC = 8 + MATCH_p; 
43288       
43289       #line 1249 "machine/pentium/disassembler.m"
43290       
43291 
43292               sprintf (str,  "SBBiowb", DIS_EADDR16, DIS_I8);
43293 
43294       
43295 
43296       
43297       
43298       
43299     } 
43300     goto MATCH_finished_a; 
43301     
43302   MATCH_label_a489: (void)0; /*placeholder for label*/ 
43303     { 
43304       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43305       int /* [~128..127] */ i8 = 
43306         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
43307       nextPC = 4 + MATCH_p; 
43308       
43309       #line 1243 "machine/pentium/disassembler.m"
43310       
43311 
43312               sprintf (str,  "ANDiowb", DIS_EADDR16, DIS_I8);
43313 
43314       
43315 
43316       
43317       
43318       
43319     } 
43320     goto MATCH_finished_a; 
43321     
43322   MATCH_label_a490: (void)0; /*placeholder for label*/ 
43323     { 
43324       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43325       int /* [~128..127] */ i8 = 
43326         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
43327       nextPC = 5 + MATCH_p; 
43328       
43329       #line 1243 "machine/pentium/disassembler.m"
43330       
43331 
43332               sprintf (str,  "ANDiowb", DIS_EADDR16, DIS_I8);
43333 
43334       
43335 
43336       
43337       
43338       
43339     } 
43340     goto MATCH_finished_a; 
43341     
43342   MATCH_label_a491: (void)0; /*placeholder for label*/ 
43343     { 
43344       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43345       int /* [~128..127] */ i8 = 
43346         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
43347       nextPC = 9 + MATCH_p; 
43348       
43349       #line 1243 "machine/pentium/disassembler.m"
43350       
43351 
43352               sprintf (str,  "ANDiowb", DIS_EADDR16, DIS_I8);
43353 
43354       
43355 
43356       
43357       
43358       
43359     } 
43360     goto MATCH_finished_a; 
43361     
43362   MATCH_label_a492: (void)0; /*placeholder for label*/ 
43363     { 
43364       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43365       int /* [~128..127] */ i8 = 
43366         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
43367       nextPC = 8 + MATCH_p; 
43368       
43369       #line 1243 "machine/pentium/disassembler.m"
43370       
43371 
43372               sprintf (str,  "ANDiowb", DIS_EADDR16, DIS_I8);
43373 
43374       
43375 
43376       
43377       
43378       
43379     } 
43380     goto MATCH_finished_a; 
43381     
43382   MATCH_label_a493: (void)0; /*placeholder for label*/ 
43383     { 
43384       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43385       int /* [~128..127] */ i8 = 
43386         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
43387       nextPC = 4 + MATCH_p; 
43388       
43389       #line 1237 "machine/pentium/disassembler.m"
43390       
43391 
43392               sprintf (str,  "SUBiowb", DIS_EADDR16, DIS_I8);
43393 
43394       
43395 
43396       
43397       
43398       
43399     } 
43400     goto MATCH_finished_a; 
43401     
43402   MATCH_label_a494: (void)0; /*placeholder for label*/ 
43403     { 
43404       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43405       int /* [~128..127] */ i8 = 
43406         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
43407       nextPC = 5 + MATCH_p; 
43408       
43409       #line 1237 "machine/pentium/disassembler.m"
43410       
43411 
43412               sprintf (str,  "SUBiowb", DIS_EADDR16, DIS_I8);
43413 
43414       
43415 
43416       
43417       
43418       
43419     } 
43420     goto MATCH_finished_a; 
43421     
43422   MATCH_label_a495: (void)0; /*placeholder for label*/ 
43423     { 
43424       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43425       int /* [~128..127] */ i8 = 
43426         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
43427       nextPC = 9 + MATCH_p; 
43428       
43429       #line 1237 "machine/pentium/disassembler.m"
43430       
43431 
43432               sprintf (str,  "SUBiowb", DIS_EADDR16, DIS_I8);
43433 
43434       
43435 
43436       
43437       
43438       
43439     } 
43440     goto MATCH_finished_a; 
43441     
43442   MATCH_label_a496: (void)0; /*placeholder for label*/ 
43443     { 
43444       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43445       int /* [~128..127] */ i8 = 
43446         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
43447       nextPC = 8 + MATCH_p; 
43448       
43449       #line 1237 "machine/pentium/disassembler.m"
43450       
43451 
43452               sprintf (str,  "SUBiowb", DIS_EADDR16, DIS_I8);
43453 
43454       
43455 
43456       
43457       
43458       
43459     } 
43460     goto MATCH_finished_a; 
43461     
43462   MATCH_label_a497: (void)0; /*placeholder for label*/ 
43463     { 
43464       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43465       int /* [~128..127] */ i8 = 
43466         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
43467       nextPC = 4 + MATCH_p; 
43468       
43469       #line 1231 "machine/pentium/disassembler.m"
43470       
43471 
43472               sprintf (str,  "XORiowb", DIS_EADDR16, DIS_I8);
43473 
43474       
43475 
43476       
43477       
43478       
43479     } 
43480     goto MATCH_finished_a; 
43481     
43482   MATCH_label_a498: (void)0; /*placeholder for label*/ 
43483     { 
43484       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43485       int /* [~128..127] */ i8 = 
43486         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
43487       nextPC = 5 + MATCH_p; 
43488       
43489       #line 1231 "machine/pentium/disassembler.m"
43490       
43491 
43492               sprintf (str,  "XORiowb", DIS_EADDR16, DIS_I8);
43493 
43494       
43495 
43496       
43497       
43498       
43499     } 
43500     goto MATCH_finished_a; 
43501     
43502   MATCH_label_a499: (void)0; /*placeholder for label*/ 
43503     { 
43504       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43505       int /* [~128..127] */ i8 = 
43506         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
43507       nextPC = 9 + MATCH_p; 
43508       
43509       #line 1231 "machine/pentium/disassembler.m"
43510       
43511 
43512               sprintf (str,  "XORiowb", DIS_EADDR16, DIS_I8);
43513 
43514       
43515 
43516       
43517       
43518       
43519     } 
43520     goto MATCH_finished_a; 
43521     
43522   MATCH_label_a500: (void)0; /*placeholder for label*/ 
43523     { 
43524       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43525       int /* [~128..127] */ i8 = 
43526         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
43527       nextPC = 8 + MATCH_p; 
43528       
43529       #line 1231 "machine/pentium/disassembler.m"
43530       
43531 
43532               sprintf (str,  "XORiowb", DIS_EADDR16, DIS_I8);
43533 
43534       
43535 
43536       
43537       
43538       
43539     } 
43540     goto MATCH_finished_a; 
43541     
43542   MATCH_label_a501: (void)0; /*placeholder for label*/ 
43543     { 
43544       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43545       int /* [~128..127] */ i8 = 
43546         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
43547       nextPC = 4 + MATCH_p; 
43548       
43549       #line 1225 "machine/pentium/disassembler.m"
43550       
43551 
43552               sprintf (str,  "CMPiowb", DIS_EADDR16, DIS_I8);
43553 
43554       
43555 
43556       
43557       
43558       
43559     } 
43560     goto MATCH_finished_a; 
43561     
43562   MATCH_label_a502: (void)0; /*placeholder for label*/ 
43563     { 
43564       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43565       int /* [~128..127] */ i8 = 
43566         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
43567       nextPC = 5 + MATCH_p; 
43568       
43569       #line 1225 "machine/pentium/disassembler.m"
43570       
43571 
43572               sprintf (str,  "CMPiowb", DIS_EADDR16, DIS_I8);
43573 
43574       
43575 
43576       
43577       
43578       
43579     } 
43580     goto MATCH_finished_a; 
43581     
43582   MATCH_label_a503: (void)0; /*placeholder for label*/ 
43583     { 
43584       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43585       int /* [~128..127] */ i8 = 
43586         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
43587       nextPC = 9 + MATCH_p; 
43588       
43589       #line 1225 "machine/pentium/disassembler.m"
43590       
43591 
43592               sprintf (str,  "CMPiowb", DIS_EADDR16, DIS_I8);
43593 
43594       
43595 
43596       
43597       
43598       
43599     } 
43600     goto MATCH_finished_a; 
43601     
43602   MATCH_label_a504: (void)0; /*placeholder for label*/ 
43603     { 
43604       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43605       int /* [~128..127] */ i8 = 
43606         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
43607       nextPC = 8 + MATCH_p; 
43608       
43609       #line 1225 "machine/pentium/disassembler.m"
43610       
43611 
43612               sprintf (str,  "CMPiowb", DIS_EADDR16, DIS_I8);
43613 
43614       
43615 
43616       
43617       
43618       
43619     } 
43620     goto MATCH_finished_a; 
43621     
43622   MATCH_label_a505: (void)0; /*placeholder for label*/ 
43623     { 
43624       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43625       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
43626       nextPC = 3 + MATCH_p; 
43627       
43628       #line 730 "machine/pentium/disassembler.m"
43629       
43630 
43631               sprintf (str,  "MOVrmow", DIS_REG16, DIS_EADDR16);
43632 
43633       
43634 
43635       
43636       
43637       
43638     } 
43639     goto MATCH_finished_a; 
43640     
43641   MATCH_label_a506: (void)0; /*placeholder for label*/ 
43642     { 
43643       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43644       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
43645       nextPC = 4 + MATCH_p; 
43646       
43647       #line 730 "machine/pentium/disassembler.m"
43648       
43649 
43650               sprintf (str,  "MOVrmow", DIS_REG16, DIS_EADDR16);
43651 
43652       
43653 
43654       
43655       
43656       
43657     } 
43658     goto MATCH_finished_a; 
43659     
43660   MATCH_label_a507: (void)0; /*placeholder for label*/ 
43661     { 
43662       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43663       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
43664       nextPC = 8 + MATCH_p; 
43665       
43666       #line 730 "machine/pentium/disassembler.m"
43667       
43668 
43669               sprintf (str,  "MOVrmow", DIS_REG16, DIS_EADDR16);
43670 
43671       
43672 
43673       
43674       
43675       
43676     } 
43677     goto MATCH_finished_a; 
43678     
43679   MATCH_label_a508: (void)0; /*placeholder for label*/ 
43680     { 
43681       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43682       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
43683       nextPC = 7 + MATCH_p; 
43684       
43685       #line 730 "machine/pentium/disassembler.m"
43686       
43687 
43688               sprintf (str,  "MOVrmow", DIS_REG16, DIS_EADDR16);
43689 
43690       
43691 
43692       
43693       
43694       
43695     } 
43696     goto MATCH_finished_a; 
43697     
43698   MATCH_label_a509: (void)0; /*placeholder for label*/ 
43699     { 
43700       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43701       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
43702       nextPC = 3 + MATCH_p; 
43703       
43704       #line 98 "machine/pentium/disassembler.m"
43705       
43706 
43707               sprintf (str,  "TEST.Ev.Gvow", DIS_EADDR16, DIS_REG16);
43708 
43709       
43710 
43711       
43712       
43713       
43714     } 
43715     goto MATCH_finished_a; 
43716     
43717   MATCH_label_a510: (void)0; /*placeholder for label*/ 
43718     { 
43719       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43720       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
43721       nextPC = 4 + MATCH_p; 
43722       
43723       #line 98 "machine/pentium/disassembler.m"
43724       
43725 
43726               sprintf (str,  "TEST.Ev.Gvow", DIS_EADDR16, DIS_REG16);
43727 
43728       
43729 
43730       
43731       
43732       
43733     } 
43734     goto MATCH_finished_a; 
43735     
43736   MATCH_label_a511: (void)0; /*placeholder for label*/ 
43737     { 
43738       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43739       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
43740       nextPC = 8 + MATCH_p; 
43741       
43742       #line 98 "machine/pentium/disassembler.m"
43743       
43744 
43745               sprintf (str,  "TEST.Ev.Gvow", DIS_EADDR16, DIS_REG16);
43746 
43747       
43748 
43749       
43750       
43751       
43752     } 
43753     goto MATCH_finished_a; 
43754     
43755   MATCH_label_a512: (void)0; /*placeholder for label*/ 
43756     { 
43757       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43758       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
43759       nextPC = 7 + MATCH_p; 
43760       
43761       #line 98 "machine/pentium/disassembler.m"
43762       
43763 
43764               sprintf (str,  "TEST.Ev.Gvow", DIS_EADDR16, DIS_REG16);
43765 
43766       
43767 
43768       
43769       
43770       
43771     } 
43772     goto MATCH_finished_a; 
43773     
43774   MATCH_label_a513: (void)0; /*placeholder for label*/ 
43775     { 
43776       unsigned Mem = 2 + addressToPC(MATCH_p);
43777       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
43778       nextPC = 4 + MATCH_p; 
43779       
43780       #line 781 "machine/pentium/disassembler.m"
43781       
43782 
43783               sprintf (str,  "LEA.ow", DIS_REG16, DIS_MEM);
43784 
43785       
43786 
43787       
43788       
43789       
43790     } 
43791     goto MATCH_finished_a; 
43792     
43793   MATCH_label_a514: (void)0; /*placeholder for label*/ 
43794     { 
43795       unsigned Mem = 2 + addressToPC(MATCH_p);
43796       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
43797       nextPC = 8 + MATCH_p; 
43798       
43799       #line 781 "machine/pentium/disassembler.m"
43800       
43801 
43802               sprintf (str,  "LEA.ow", DIS_REG16, DIS_MEM);
43803 
43804       
43805 
43806       
43807       
43808       
43809     } 
43810     goto MATCH_finished_a; 
43811     
43812   MATCH_label_a515: (void)0; /*placeholder for label*/ 
43813     { 
43814       unsigned Mem = 2 + addressToPC(MATCH_p);
43815       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
43816       nextPC = 7 + MATCH_p; 
43817       
43818       #line 781 "machine/pentium/disassembler.m"
43819       
43820 
43821               sprintf (str,  "LEA.ow", DIS_REG16, DIS_MEM);
43822 
43823       
43824 
43825       
43826       
43827       
43828     } 
43829     goto MATCH_finished_a; 
43830     
43831   MATCH_label_a516: (void)0; /*placeholder for label*/ 
43832     { 
43833       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43834       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
43835       nextPC = 3 + MATCH_p; 
43836       
43837       #line 50 "machine/pentium/disassembler.m"
43838       
43839 
43840               sprintf (str, "%s %s,%s", "XCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
43841 
43842       
43843 
43844       
43845       
43846       
43847     } 
43848     goto MATCH_finished_a; 
43849     
43850   MATCH_label_a517: (void)0; /*placeholder for label*/ 
43851     { 
43852       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43853       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
43854       nextPC = 4 + MATCH_p; 
43855       
43856       #line 50 "machine/pentium/disassembler.m"
43857       
43858 
43859               sprintf (str, "%s %s,%s", "XCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
43860 
43861       
43862 
43863       
43864       
43865       
43866     } 
43867     goto MATCH_finished_a; 
43868     
43869   MATCH_label_a518: (void)0; /*placeholder for label*/ 
43870     { 
43871       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43872       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
43873       nextPC = 8 + MATCH_p; 
43874       
43875       #line 50 "machine/pentium/disassembler.m"
43876       
43877 
43878               sprintf (str, "%s %s,%s", "XCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
43879 
43880       
43881 
43882       
43883       
43884       
43885     } 
43886     goto MATCH_finished_a; 
43887     
43888   MATCH_label_a519: (void)0; /*placeholder for label*/ 
43889     { 
43890       unsigned Eaddr = 2 + addressToPC(MATCH_p);
43891       unsigned reg = (MATCH_w_8_16 >> 3 & 0x7) /* reg_opcode at 16 */;
43892       nextPC = 7 + MATCH_p; 
43893       
43894       #line 50 "machine/pentium/disassembler.m"
43895       
43896 
43897               sprintf (str, "%s %s,%s", "XCHG.Ev.Gvow", DIS_EADDR16, DIS_REG16);
43898 
43899       
43900 
43901       
43902       
43903       
43904     } 
43905     goto MATCH_finished_a; 
43906     
43907   MATCH_label_a520: (void)0; /*placeholder for label*/ 
43908     { 
43909       unsigned Mem = 2 + addressToPC(MATCH_p);
43910       nextPC = 4 + MATCH_p; 
43911       
43912       #line 585 "machine/pentium/disassembler.m"
43913       
43914 
43915               sprintf (str,  "POP.Evow", DIS_MEM);
43916 
43917       
43918 
43919       //    | OUTSvod() =>
43920 
43921       //        sprintf (str,  "OUTSvod");
43922 
43923       
43924 
43925       //    | OUTSvow() =>
43926 
43927       //        sprintf (str,  "OUTSvow");
43928 
43929       
43930 
43931       //    | OUTSB() =>
43932 
43933       //        sprintf (str,  "OUTSB");
43934 
43935       
43936 
43937       //    | OUT.DX.eAXod() =>
43938 
43939       //        sprintf (str,  "OUT.DX.eAXod");
43940 
43941       
43942 
43943       //    | OUT.DX.eAXow() =>
43944 
43945       //        sprintf (str,  "OUT.DX.eAXow");
43946 
43947       
43948 
43949       //    | OUT.DX.AL() =>
43950 
43951       //        sprintf (str,  "OUT.DX.AL");
43952 
43953       
43954 
43955       //    | OUT.Ib.eAXod(i8) =>
43956 
43957       //        sprintf (str,  "OUT.Ib.eAXod", DIS_I8);
43958 
43959       
43960 
43961       //    | OUT.Ib.eAXow(i8) =>
43962 
43963       //        sprintf (str,  "OUT.Ib.eAXow", DIS_I8);
43964 
43965       
43966 
43967       //    | OUT.Ib.AL(i8) =>
43968 
43969       //        sprintf (str,  "OUT.Ib.AL", DIS_I8);
43970 
43971       
43972 
43973       
43974       
43975       
43976     } 
43977     goto MATCH_finished_a; 
43978     
43979   MATCH_label_a521: (void)0; /*placeholder for label*/ 
43980     { 
43981       unsigned Mem = 2 + addressToPC(MATCH_p);
43982       nextPC = 8 + MATCH_p; 
43983       
43984       #line 585 "machine/pentium/disassembler.m"
43985       
43986 
43987               sprintf (str,  "POP.Evow", DIS_MEM);
43988 
43989       
43990 
43991       //    | OUTSvod() =>
43992 
43993       //        sprintf (str,  "OUTSvod");
43994 
43995       
43996 
43997       //    | OUTSvow() =>
43998 
43999       //        sprintf (str,  "OUTSvow");
44000 
44001       
44002 
44003       //    | OUTSB() =>
44004 
44005       //        sprintf (str,  "OUTSB");
44006 
44007       
44008 
44009       //    | OUT.DX.eAXod() =>
44010 
44011       //        sprintf (str,  "OUT.DX.eAXod");
44012 
44013       
44014 
44015       //    | OUT.DX.eAXow() =>
44016 
44017       //        sprintf (str,  "OUT.DX.eAXow");
44018 
44019       
44020 
44021       //    | OUT.DX.AL() =>
44022 
44023       //        sprintf (str,  "OUT.DX.AL");
44024 
44025       
44026 
44027       //    | OUT.Ib.eAXod(i8) =>
44028 
44029       //        sprintf (str,  "OUT.Ib.eAXod", DIS_I8);
44030 
44031       
44032 
44033       //    | OUT.Ib.eAXow(i8) =>
44034 
44035       //        sprintf (str,  "OUT.Ib.eAXow", DIS_I8);
44036 
44037       
44038 
44039       //    | OUT.Ib.AL(i8) =>
44040 
44041       //        sprintf (str,  "OUT.Ib.AL", DIS_I8);
44042 
44043       
44044 
44045       
44046       
44047       
44048     } 
44049     goto MATCH_finished_a; 
44050     
44051   MATCH_label_a522: (void)0; /*placeholder for label*/ 
44052     { 
44053       unsigned Mem = 2 + addressToPC(MATCH_p);
44054       nextPC = 7 + MATCH_p; 
44055       
44056       #line 585 "machine/pentium/disassembler.m"
44057       
44058 
44059               sprintf (str,  "POP.Evow", DIS_MEM);
44060 
44061       
44062 
44063       //    | OUTSvod() =>
44064 
44065       //        sprintf (str,  "OUTSvod");
44066 
44067       
44068 
44069       //    | OUTSvow() =>
44070 
44071       //        sprintf (str,  "OUTSvow");
44072 
44073       
44074 
44075       //    | OUTSB() =>
44076 
44077       //        sprintf (str,  "OUTSB");
44078 
44079       
44080 
44081       //    | OUT.DX.eAXod() =>
44082 
44083       //        sprintf (str,  "OUT.DX.eAXod");
44084 
44085       
44086 
44087       //    | OUT.DX.eAXow() =>
44088 
44089       //        sprintf (str,  "OUT.DX.eAXow");
44090 
44091       
44092 
44093       //    | OUT.DX.AL() =>
44094 
44095       //        sprintf (str,  "OUT.DX.AL");
44096 
44097       
44098 
44099       //    | OUT.Ib.eAXod(i8) =>
44100 
44101       //        sprintf (str,  "OUT.Ib.eAXod", DIS_I8);
44102 
44103       
44104 
44105       //    | OUT.Ib.eAXow(i8) =>
44106 
44107       //        sprintf (str,  "OUT.Ib.eAXow", DIS_I8);
44108 
44109       
44110 
44111       //    | OUT.Ib.AL(i8) =>
44112 
44113       //        sprintf (str,  "OUT.Ib.AL", DIS_I8);
44114 
44115       
44116 
44117       
44118       
44119       
44120     } 
44121     goto MATCH_finished_a; 
44122     
44123   MATCH_label_a523: (void)0; /*placeholder for label*/ 
44124     { 
44125       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44126       int /* [~128..127] */ i8 = 
44127         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
44128       nextPC = 4 + MATCH_p; 
44129       
44130       #line 345 "machine/pentium/disassembler.m"
44131       
44132 
44133               sprintf (str,  "ROLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44134 
44135       
44136 
44137       
44138       
44139       
44140     } 
44141     goto MATCH_finished_a; 
44142     
44143   MATCH_label_a524: (void)0; /*placeholder for label*/ 
44144     { 
44145       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44146       int /* [~128..127] */ i8 = 
44147         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
44148       nextPC = 5 + MATCH_p; 
44149       
44150       #line 345 "machine/pentium/disassembler.m"
44151       
44152 
44153               sprintf (str,  "ROLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44154 
44155       
44156 
44157       
44158       
44159       
44160     } 
44161     goto MATCH_finished_a; 
44162     
44163   MATCH_label_a525: (void)0; /*placeholder for label*/ 
44164     { 
44165       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44166       int /* [~128..127] */ i8 = 
44167         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
44168       nextPC = 9 + MATCH_p; 
44169       
44170       #line 345 "machine/pentium/disassembler.m"
44171       
44172 
44173               sprintf (str,  "ROLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44174 
44175       
44176 
44177       
44178       
44179       
44180     } 
44181     goto MATCH_finished_a; 
44182     
44183   MATCH_label_a526: (void)0; /*placeholder for label*/ 
44184     { 
44185       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44186       int /* [~128..127] */ i8 = 
44187         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
44188       nextPC = 8 + MATCH_p; 
44189       
44190       #line 345 "machine/pentium/disassembler.m"
44191       
44192 
44193               sprintf (str,  "ROLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44194 
44195       
44196 
44197       
44198       
44199       
44200     } 
44201     goto MATCH_finished_a; 
44202     
44203   MATCH_label_a527: (void)0; /*placeholder for label*/ 
44204     { 
44205       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44206       int /* [~128..127] */ i8 = 
44207         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
44208       nextPC = 4 + MATCH_p; 
44209       
44210       #line 339 "machine/pentium/disassembler.m"
44211       
44212 
44213               sprintf (str,  "RORB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44214 
44215       
44216 
44217       
44218       
44219       
44220     } 
44221     goto MATCH_finished_a; 
44222     
44223   MATCH_label_a528: (void)0; /*placeholder for label*/ 
44224     { 
44225       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44226       int /* [~128..127] */ i8 = 
44227         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
44228       nextPC = 5 + MATCH_p; 
44229       
44230       #line 339 "machine/pentium/disassembler.m"
44231       
44232 
44233               sprintf (str,  "RORB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44234 
44235       
44236 
44237       
44238       
44239       
44240     } 
44241     goto MATCH_finished_a; 
44242     
44243   MATCH_label_a529: (void)0; /*placeholder for label*/ 
44244     { 
44245       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44246       int /* [~128..127] */ i8 = 
44247         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
44248       nextPC = 9 + MATCH_p; 
44249       
44250       #line 339 "machine/pentium/disassembler.m"
44251       
44252 
44253               sprintf (str,  "RORB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44254 
44255       
44256 
44257       
44258       
44259       
44260     } 
44261     goto MATCH_finished_a; 
44262     
44263   MATCH_label_a530: (void)0; /*placeholder for label*/ 
44264     { 
44265       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44266       int /* [~128..127] */ i8 = 
44267         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
44268       nextPC = 8 + MATCH_p; 
44269       
44270       #line 339 "machine/pentium/disassembler.m"
44271       
44272 
44273               sprintf (str,  "RORB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44274 
44275       
44276 
44277       
44278       
44279       
44280     } 
44281     goto MATCH_finished_a; 
44282     
44283   MATCH_label_a531: (void)0; /*placeholder for label*/ 
44284     { 
44285       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44286       int /* [~128..127] */ i8 = 
44287         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
44288       nextPC = 4 + MATCH_p; 
44289       
44290       #line 333 "machine/pentium/disassembler.m"
44291       
44292 
44293               sprintf (str,  "RCLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44294 
44295       
44296 
44297       
44298       
44299       
44300     } 
44301     goto MATCH_finished_a; 
44302     
44303   MATCH_label_a532: (void)0; /*placeholder for label*/ 
44304     { 
44305       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44306       int /* [~128..127] */ i8 = 
44307         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
44308       nextPC = 5 + MATCH_p; 
44309       
44310       #line 333 "machine/pentium/disassembler.m"
44311       
44312 
44313               sprintf (str,  "RCLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44314 
44315       
44316 
44317       
44318       
44319       
44320     } 
44321     goto MATCH_finished_a; 
44322     
44323   MATCH_label_a533: (void)0; /*placeholder for label*/ 
44324     { 
44325       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44326       int /* [~128..127] */ i8 = 
44327         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
44328       nextPC = 9 + MATCH_p; 
44329       
44330       #line 333 "machine/pentium/disassembler.m"
44331       
44332 
44333               sprintf (str,  "RCLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44334 
44335       
44336 
44337       
44338       
44339       
44340     } 
44341     goto MATCH_finished_a; 
44342     
44343   MATCH_label_a534: (void)0; /*placeholder for label*/ 
44344     { 
44345       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44346       int /* [~128..127] */ i8 = 
44347         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
44348       nextPC = 8 + MATCH_p; 
44349       
44350       #line 333 "machine/pentium/disassembler.m"
44351       
44352 
44353               sprintf (str,  "RCLB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44354 
44355       
44356 
44357       
44358       
44359       
44360     } 
44361     goto MATCH_finished_a; 
44362     
44363   MATCH_label_a535: (void)0; /*placeholder for label*/ 
44364     { 
44365       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44366       int /* [~128..127] */ i8 = 
44367         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
44368       nextPC = 4 + MATCH_p; 
44369       
44370       #line 327 "machine/pentium/disassembler.m"
44371       
44372 
44373               sprintf (str,  "RCRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44374 
44375       
44376 
44377       
44378       
44379       
44380     } 
44381     goto MATCH_finished_a; 
44382     
44383   MATCH_label_a536: (void)0; /*placeholder for label*/ 
44384     { 
44385       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44386       int /* [~128..127] */ i8 = 
44387         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
44388       nextPC = 5 + MATCH_p; 
44389       
44390       #line 327 "machine/pentium/disassembler.m"
44391       
44392 
44393               sprintf (str,  "RCRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44394 
44395       
44396 
44397       
44398       
44399       
44400     } 
44401     goto MATCH_finished_a; 
44402     
44403   MATCH_label_a537: (void)0; /*placeholder for label*/ 
44404     { 
44405       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44406       int /* [~128..127] */ i8 = 
44407         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
44408       nextPC = 9 + MATCH_p; 
44409       
44410       #line 327 "machine/pentium/disassembler.m"
44411       
44412 
44413               sprintf (str,  "RCRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44414 
44415       
44416 
44417       
44418       
44419       
44420     } 
44421     goto MATCH_finished_a; 
44422     
44423   MATCH_label_a538: (void)0; /*placeholder for label*/ 
44424     { 
44425       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44426       int /* [~128..127] */ i8 = 
44427         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
44428       nextPC = 8 + MATCH_p; 
44429       
44430       #line 327 "machine/pentium/disassembler.m"
44431       
44432 
44433               sprintf (str,  "RCRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44434 
44435       
44436 
44437       
44438       
44439       
44440     } 
44441     goto MATCH_finished_a; 
44442     
44443   MATCH_label_a539: (void)0; /*placeholder for label*/ 
44444     { 
44445       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44446       int /* [~128..127] */ i8 = 
44447         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
44448       nextPC = 4 + MATCH_p; 
44449       
44450       #line 321 "machine/pentium/disassembler.m"
44451       
44452 
44453               sprintf (str,  "SHLSALB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44454 
44455       
44456 
44457       
44458       
44459       
44460     } 
44461     goto MATCH_finished_a; 
44462     
44463   MATCH_label_a540: (void)0; /*placeholder for label*/ 
44464     { 
44465       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44466       int /* [~128..127] */ i8 = 
44467         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
44468       nextPC = 5 + MATCH_p; 
44469       
44470       #line 321 "machine/pentium/disassembler.m"
44471       
44472 
44473               sprintf (str,  "SHLSALB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44474 
44475       
44476 
44477       
44478       
44479       
44480     } 
44481     goto MATCH_finished_a; 
44482     
44483   MATCH_label_a541: (void)0; /*placeholder for label*/ 
44484     { 
44485       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44486       int /* [~128..127] */ i8 = 
44487         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
44488       nextPC = 9 + MATCH_p; 
44489       
44490       #line 321 "machine/pentium/disassembler.m"
44491       
44492 
44493               sprintf (str,  "SHLSALB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44494 
44495       
44496 
44497       
44498       
44499       
44500     } 
44501     goto MATCH_finished_a; 
44502     
44503   MATCH_label_a542: (void)0; /*placeholder for label*/ 
44504     { 
44505       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44506       int /* [~128..127] */ i8 = 
44507         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
44508       nextPC = 8 + MATCH_p; 
44509       
44510       #line 321 "machine/pentium/disassembler.m"
44511       
44512 
44513               sprintf (str,  "SHLSALB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44514 
44515       
44516 
44517       
44518       
44519       
44520     } 
44521     goto MATCH_finished_a; 
44522     
44523   MATCH_label_a543: (void)0; /*placeholder for label*/ 
44524     { 
44525       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44526       int /* [~128..127] */ i8 = 
44527         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
44528       nextPC = 4 + MATCH_p; 
44529       
44530       #line 315 "machine/pentium/disassembler.m"
44531       
44532 
44533               sprintf (str,  "SHRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44534 
44535       
44536 
44537       
44538       
44539       
44540     } 
44541     goto MATCH_finished_a; 
44542     
44543   MATCH_label_a544: (void)0; /*placeholder for label*/ 
44544     { 
44545       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44546       int /* [~128..127] */ i8 = 
44547         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
44548       nextPC = 5 + MATCH_p; 
44549       
44550       #line 315 "machine/pentium/disassembler.m"
44551       
44552 
44553               sprintf (str,  "SHRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44554 
44555       
44556 
44557       
44558       
44559       
44560     } 
44561     goto MATCH_finished_a; 
44562     
44563   MATCH_label_a545: (void)0; /*placeholder for label*/ 
44564     { 
44565       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44566       int /* [~128..127] */ i8 = 
44567         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
44568       nextPC = 9 + MATCH_p; 
44569       
44570       #line 315 "machine/pentium/disassembler.m"
44571       
44572 
44573               sprintf (str,  "SHRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44574 
44575       
44576 
44577       
44578       
44579       
44580     } 
44581     goto MATCH_finished_a; 
44582     
44583   MATCH_label_a546: (void)0; /*placeholder for label*/ 
44584     { 
44585       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44586       int /* [~128..127] */ i8 = 
44587         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
44588       nextPC = 8 + MATCH_p; 
44589       
44590       #line 315 "machine/pentium/disassembler.m"
44591       
44592 
44593               sprintf (str,  "SHRB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44594 
44595       
44596 
44597       
44598       
44599       
44600     } 
44601     goto MATCH_finished_a; 
44602     
44603   MATCH_label_a547: (void)0; /*placeholder for label*/ 
44604     { 
44605       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44606       int /* [~128..127] */ i8 = 
44607         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
44608       nextPC = 4 + MATCH_p; 
44609       
44610       #line 309 "machine/pentium/disassembler.m"
44611       
44612 
44613               sprintf (str,  "SARB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44614 
44615       
44616 
44617       
44618       
44619       
44620     } 
44621     goto MATCH_finished_a; 
44622     
44623   MATCH_label_a548: (void)0; /*placeholder for label*/ 
44624     { 
44625       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44626       int /* [~128..127] */ i8 = 
44627         sign_extend((MATCH_w_8_32 & 0xff) /* i8 at 32 */, 8);
44628       nextPC = 5 + MATCH_p; 
44629       
44630       #line 309 "machine/pentium/disassembler.m"
44631       
44632 
44633               sprintf (str,  "SARB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44634 
44635       
44636 
44637       
44638       
44639       
44640     } 
44641     goto MATCH_finished_a; 
44642     
44643   MATCH_label_a549: (void)0; /*placeholder for label*/ 
44644     { 
44645       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44646       int /* [~128..127] */ i8 = 
44647         sign_extend((MATCH_w_8_64 & 0xff) /* i8 at 64 */, 8);
44648       nextPC = 9 + MATCH_p; 
44649       
44650       #line 309 "machine/pentium/disassembler.m"
44651       
44652 
44653               sprintf (str,  "SARB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44654 
44655       
44656 
44657       
44658       
44659       
44660     } 
44661     goto MATCH_finished_a; 
44662     
44663   MATCH_label_a550: (void)0; /*placeholder for label*/ 
44664     { 
44665       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44666       int /* [~128..127] */ i8 = 
44667         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
44668       nextPC = 8 + MATCH_p; 
44669       
44670       #line 309 "machine/pentium/disassembler.m"
44671       
44672 
44673               sprintf (str,  "SARB.Ev.Ibow", DIS_EADDR16, DIS_I8);
44674 
44675       
44676 
44677       
44678       
44679       
44680     } 
44681     goto MATCH_finished_a; 
44682     
44683   MATCH_label_a551: (void)0; /*placeholder for label*/ 
44684     { 
44685       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44686       int /* [~32768..32767] */ i16 = 
44687         sign_extend((MATCH_w_16_24 & 0xffff) /* i16 at 24 */, 16);
44688       nextPC = 5 + MATCH_p; 
44689       
44690       #line 688 "machine/pentium/disassembler.m"
44691       
44692 
44693               sprintf (str,  "MOV.Eb.Ivow", DIS_EADDR16, DIS_I16);
44694 
44695       
44696 
44697       
44698       
44699       
44700     } 
44701     goto MATCH_finished_a; 
44702     
44703   MATCH_label_a552: (void)0; /*placeholder for label*/ 
44704     { 
44705       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44706       int /* [~32768..32767] */ i16 = 
44707         sign_extend((MATCH_w_16_32 & 0xffff) /* i16 at 32 */, 16);
44708       nextPC = 6 + MATCH_p; 
44709       
44710       #line 688 "machine/pentium/disassembler.m"
44711       
44712 
44713               sprintf (str,  "MOV.Eb.Ivow", DIS_EADDR16, DIS_I16);
44714 
44715       
44716 
44717       
44718       
44719       
44720     } 
44721     goto MATCH_finished_a; 
44722     
44723   MATCH_label_a553: (void)0; /*placeholder for label*/ 
44724     { 
44725       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44726       int /* [~32768..32767] */ i16 = 
44727         sign_extend((MATCH_w_16_64 & 0xffff) /* i16 at 64 */, 16);
44728       nextPC = 10 + MATCH_p; 
44729       
44730       #line 688 "machine/pentium/disassembler.m"
44731       
44732 
44733               sprintf (str,  "MOV.Eb.Ivow", DIS_EADDR16, DIS_I16);
44734 
44735       
44736 
44737       
44738       
44739       
44740     } 
44741     goto MATCH_finished_a; 
44742     
44743   MATCH_label_a554: (void)0; /*placeholder for label*/ 
44744     { 
44745       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44746       int /* [~32768..32767] */ i16 = 
44747         sign_extend((MATCH_w_16_56 & 0xffff) /* i16 at 56 */, 16);
44748       nextPC = 9 + MATCH_p; 
44749       
44750       #line 688 "machine/pentium/disassembler.m"
44751       
44752 
44753               sprintf (str,  "MOV.Eb.Ivow", DIS_EADDR16, DIS_I16);
44754 
44755       
44756 
44757       
44758       
44759       
44760     } 
44761     goto MATCH_finished_a; 
44762     
44763   MATCH_label_a555: (void)0; /*placeholder for label*/ 
44764     { 
44765       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44766       nextPC = 3 + MATCH_p; 
44767       
44768       #line 450 "machine/pentium/disassembler.m"
44769       
44770 
44771               sprintf (str,  "ROLB.Ev.1ow", DIS_EADDR16);
44772 
44773       
44774 
44775       
44776       
44777       
44778     } 
44779     goto MATCH_finished_a; 
44780     
44781   MATCH_label_a556: (void)0; /*placeholder for label*/ 
44782     { 
44783       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44784       nextPC = 4 + MATCH_p; 
44785       
44786       #line 450 "machine/pentium/disassembler.m"
44787       
44788 
44789               sprintf (str,  "ROLB.Ev.1ow", DIS_EADDR16);
44790 
44791       
44792 
44793       
44794       
44795       
44796     } 
44797     goto MATCH_finished_a; 
44798     
44799   MATCH_label_a557: (void)0; /*placeholder for label*/ 
44800     { 
44801       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44802       nextPC = 8 + MATCH_p; 
44803       
44804       #line 450 "machine/pentium/disassembler.m"
44805       
44806 
44807               sprintf (str,  "ROLB.Ev.1ow", DIS_EADDR16);
44808 
44809       
44810 
44811       
44812       
44813       
44814     } 
44815     goto MATCH_finished_a; 
44816     
44817   MATCH_label_a558: (void)0; /*placeholder for label*/ 
44818     { 
44819       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44820       nextPC = 7 + MATCH_p; 
44821       
44822       #line 450 "machine/pentium/disassembler.m"
44823       
44824 
44825               sprintf (str,  "ROLB.Ev.1ow", DIS_EADDR16);
44826 
44827       
44828 
44829       
44830       
44831       
44832     } 
44833     goto MATCH_finished_a; 
44834     
44835   MATCH_label_a559: (void)0; /*placeholder for label*/ 
44836     { 
44837       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44838       nextPC = 3 + MATCH_p; 
44839       
44840       #line 438 "machine/pentium/disassembler.m"
44841       
44842 
44843               sprintf (str,  "ORB.Ev.1owR", DIS_EADDR16);
44844 
44845       
44846 
44847       
44848       
44849       
44850     } 
44851     goto MATCH_finished_a; 
44852     
44853   MATCH_label_a560: (void)0; /*placeholder for label*/ 
44854     { 
44855       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44856       nextPC = 4 + MATCH_p; 
44857       
44858       #line 438 "machine/pentium/disassembler.m"
44859       
44860 
44861               sprintf (str,  "ORB.Ev.1owR", DIS_EADDR16);
44862 
44863       
44864 
44865       
44866       
44867       
44868     } 
44869     goto MATCH_finished_a; 
44870     
44871   MATCH_label_a561: (void)0; /*placeholder for label*/ 
44872     { 
44873       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44874       nextPC = 8 + MATCH_p; 
44875       
44876       #line 438 "machine/pentium/disassembler.m"
44877       
44878 
44879               sprintf (str,  "ORB.Ev.1owR", DIS_EADDR16);
44880 
44881       
44882 
44883       
44884       
44885       
44886     } 
44887     goto MATCH_finished_a; 
44888     
44889   MATCH_label_a562: (void)0; /*placeholder for label*/ 
44890     { 
44891       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44892       nextPC = 7 + MATCH_p; 
44893       
44894       #line 438 "machine/pentium/disassembler.m"
44895       
44896 
44897               sprintf (str,  "ORB.Ev.1owR", DIS_EADDR16);
44898 
44899       
44900 
44901       
44902       
44903       
44904     } 
44905     goto MATCH_finished_a; 
44906     
44907   MATCH_label_a563: (void)0; /*placeholder for label*/ 
44908     { 
44909       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44910       nextPC = 3 + MATCH_p; 
44911       
44912       #line 426 "machine/pentium/disassembler.m"
44913       
44914 
44915               sprintf (str,  "RCLB.Ev.1ow", DIS_EADDR16);
44916 
44917       
44918 
44919       
44920       
44921       
44922     } 
44923     goto MATCH_finished_a; 
44924     
44925   MATCH_label_a564: (void)0; /*placeholder for label*/ 
44926     { 
44927       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44928       nextPC = 4 + MATCH_p; 
44929       
44930       #line 426 "machine/pentium/disassembler.m"
44931       
44932 
44933               sprintf (str,  "RCLB.Ev.1ow", DIS_EADDR16);
44934 
44935       
44936 
44937       
44938       
44939       
44940     } 
44941     goto MATCH_finished_a; 
44942     
44943   MATCH_label_a565: (void)0; /*placeholder for label*/ 
44944     { 
44945       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44946       nextPC = 8 + MATCH_p; 
44947       
44948       #line 426 "machine/pentium/disassembler.m"
44949       
44950 
44951               sprintf (str,  "RCLB.Ev.1ow", DIS_EADDR16);
44952 
44953       
44954 
44955       
44956       
44957       
44958     } 
44959     goto MATCH_finished_a; 
44960     
44961   MATCH_label_a566: (void)0; /*placeholder for label*/ 
44962     { 
44963       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44964       nextPC = 7 + MATCH_p; 
44965       
44966       #line 426 "machine/pentium/disassembler.m"
44967       
44968 
44969               sprintf (str,  "RCLB.Ev.1ow", DIS_EADDR16);
44970 
44971       
44972 
44973       
44974       
44975       
44976     } 
44977     goto MATCH_finished_a; 
44978     
44979   MATCH_label_a567: (void)0; /*placeholder for label*/ 
44980     { 
44981       unsigned Eaddr = 2 + addressToPC(MATCH_p);
44982       nextPC = 3 + MATCH_p; 
44983       
44984       #line 414 "machine/pentium/disassembler.m"
44985       
44986 
44987               sprintf (str,  "RCRB.Ev.1ow", DIS_EADDR16);
44988 
44989       
44990 
44991       
44992       
44993       
44994     } 
44995     goto MATCH_finished_a; 
44996     
44997   MATCH_label_a568: (void)0; /*placeholder for label*/ 
44998     { 
44999       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45000       nextPC = 4 + MATCH_p; 
45001       
45002       #line 414 "machine/pentium/disassembler.m"
45003       
45004 
45005               sprintf (str,  "RCRB.Ev.1ow", DIS_EADDR16);
45006 
45007       
45008 
45009       
45010       
45011       
45012     } 
45013     goto MATCH_finished_a; 
45014     
45015   MATCH_label_a569: (void)0; /*placeholder for label*/ 
45016     { 
45017       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45018       nextPC = 8 + MATCH_p; 
45019       
45020       #line 414 "machine/pentium/disassembler.m"
45021       
45022 
45023               sprintf (str,  "RCRB.Ev.1ow", DIS_EADDR16);
45024 
45025       
45026 
45027       
45028       
45029       
45030     } 
45031     goto MATCH_finished_a; 
45032     
45033   MATCH_label_a570: (void)0; /*placeholder for label*/ 
45034     { 
45035       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45036       nextPC = 7 + MATCH_p; 
45037       
45038       #line 414 "machine/pentium/disassembler.m"
45039       
45040 
45041               sprintf (str,  "RCRB.Ev.1ow", DIS_EADDR16);
45042 
45043       
45044 
45045       
45046       
45047       
45048     } 
45049     goto MATCH_finished_a; 
45050     
45051   MATCH_label_a571: (void)0; /*placeholder for label*/ 
45052     { 
45053       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45054       nextPC = 3 + MATCH_p; 
45055       
45056       #line 402 "machine/pentium/disassembler.m"
45057       
45058 
45059               sprintf (str,  "SHLSALB.Ev.1ow", DIS_EADDR16);
45060 
45061       
45062 
45063       
45064       
45065       
45066     } 
45067     goto MATCH_finished_a; 
45068     
45069   MATCH_label_a572: (void)0; /*placeholder for label*/ 
45070     { 
45071       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45072       nextPC = 4 + MATCH_p; 
45073       
45074       #line 402 "machine/pentium/disassembler.m"
45075       
45076 
45077               sprintf (str,  "SHLSALB.Ev.1ow", DIS_EADDR16);
45078 
45079       
45080 
45081       
45082       
45083       
45084     } 
45085     goto MATCH_finished_a; 
45086     
45087   MATCH_label_a573: (void)0; /*placeholder for label*/ 
45088     { 
45089       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45090       nextPC = 8 + MATCH_p; 
45091       
45092       #line 402 "machine/pentium/disassembler.m"
45093       
45094 
45095               sprintf (str,  "SHLSALB.Ev.1ow", DIS_EADDR16);
45096 
45097       
45098 
45099       
45100       
45101       
45102     } 
45103     goto MATCH_finished_a; 
45104     
45105   MATCH_label_a574: (void)0; /*placeholder for label*/ 
45106     { 
45107       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45108       nextPC = 7 + MATCH_p; 
45109       
45110       #line 402 "machine/pentium/disassembler.m"
45111       
45112 
45113               sprintf (str,  "SHLSALB.Ev.1ow", DIS_EADDR16);
45114 
45115       
45116 
45117       
45118       
45119       
45120     } 
45121     goto MATCH_finished_a; 
45122     
45123   MATCH_label_a575: (void)0; /*placeholder for label*/ 
45124     { 
45125       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45126       nextPC = 3 + MATCH_p; 
45127       
45128       #line 390 "machine/pentium/disassembler.m"
45129       
45130 
45131               sprintf (str,  "SHRB.Ev.1ow", DIS_EADDR16);
45132 
45133       
45134 
45135       
45136       
45137       
45138     } 
45139     goto MATCH_finished_a; 
45140     
45141   MATCH_label_a576: (void)0; /*placeholder for label*/ 
45142     { 
45143       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45144       nextPC = 4 + MATCH_p; 
45145       
45146       #line 390 "machine/pentium/disassembler.m"
45147       
45148 
45149               sprintf (str,  "SHRB.Ev.1ow", DIS_EADDR16);
45150 
45151       
45152 
45153       
45154       
45155       
45156     } 
45157     goto MATCH_finished_a; 
45158     
45159   MATCH_label_a577: (void)0; /*placeholder for label*/ 
45160     { 
45161       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45162       nextPC = 8 + MATCH_p; 
45163       
45164       #line 390 "machine/pentium/disassembler.m"
45165       
45166 
45167               sprintf (str,  "SHRB.Ev.1ow", DIS_EADDR16);
45168 
45169       
45170 
45171       
45172       
45173       
45174     } 
45175     goto MATCH_finished_a; 
45176     
45177   MATCH_label_a578: (void)0; /*placeholder for label*/ 
45178     { 
45179       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45180       nextPC = 7 + MATCH_p; 
45181       
45182       #line 390 "machine/pentium/disassembler.m"
45183       
45184 
45185               sprintf (str,  "SHRB.Ev.1ow", DIS_EADDR16);
45186 
45187       
45188 
45189       
45190       
45191       
45192     } 
45193     goto MATCH_finished_a; 
45194     
45195   MATCH_label_a579: (void)0; /*placeholder for label*/ 
45196     { 
45197       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45198       nextPC = 3 + MATCH_p; 
45199       
45200       #line 378 "machine/pentium/disassembler.m"
45201       
45202 
45203               sprintf (str,  "SARB.Ev.1ow", DIS_EADDR16);
45204 
45205       
45206 
45207       
45208       
45209       
45210     } 
45211     goto MATCH_finished_a; 
45212     
45213   MATCH_label_a580: (void)0; /*placeholder for label*/ 
45214     { 
45215       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45216       nextPC = 4 + MATCH_p; 
45217       
45218       #line 378 "machine/pentium/disassembler.m"
45219       
45220 
45221               sprintf (str,  "SARB.Ev.1ow", DIS_EADDR16);
45222 
45223       
45224 
45225       
45226       
45227       
45228     } 
45229     goto MATCH_finished_a; 
45230     
45231   MATCH_label_a581: (void)0; /*placeholder for label*/ 
45232     { 
45233       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45234       nextPC = 8 + MATCH_p; 
45235       
45236       #line 378 "machine/pentium/disassembler.m"
45237       
45238 
45239               sprintf (str,  "SARB.Ev.1ow", DIS_EADDR16);
45240 
45241       
45242 
45243       
45244       
45245       
45246     } 
45247     goto MATCH_finished_a; 
45248     
45249   MATCH_label_a582: (void)0; /*placeholder for label*/ 
45250     { 
45251       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45252       nextPC = 7 + MATCH_p; 
45253       
45254       #line 378 "machine/pentium/disassembler.m"
45255       
45256 
45257               sprintf (str,  "SARB.Ev.1ow", DIS_EADDR16);
45258 
45259       
45260 
45261       
45262       
45263       
45264     } 
45265     goto MATCH_finished_a; 
45266     
45267   MATCH_label_a583: (void)0; /*placeholder for label*/ 
45268     { 
45269       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45270       nextPC = 3 + MATCH_p; 
45271       
45272       #line 444 "machine/pentium/disassembler.m"
45273       
45274 
45275               sprintf (str,  "ROLB.Ev.CLow", DIS_EADDR16);
45276 
45277       
45278 
45279       
45280       
45281       
45282     } 
45283     goto MATCH_finished_a; 
45284     
45285   MATCH_label_a584: (void)0; /*placeholder for label*/ 
45286     { 
45287       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45288       nextPC = 4 + MATCH_p; 
45289       
45290       #line 444 "machine/pentium/disassembler.m"
45291       
45292 
45293               sprintf (str,  "ROLB.Ev.CLow", DIS_EADDR16);
45294 
45295       
45296 
45297       
45298       
45299       
45300     } 
45301     goto MATCH_finished_a; 
45302     
45303   MATCH_label_a585: (void)0; /*placeholder for label*/ 
45304     { 
45305       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45306       nextPC = 8 + MATCH_p; 
45307       
45308       #line 444 "machine/pentium/disassembler.m"
45309       
45310 
45311               sprintf (str,  "ROLB.Ev.CLow", DIS_EADDR16);
45312 
45313       
45314 
45315       
45316       
45317       
45318     } 
45319     goto MATCH_finished_a; 
45320     
45321   MATCH_label_a586: (void)0; /*placeholder for label*/ 
45322     { 
45323       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45324       nextPC = 7 + MATCH_p; 
45325       
45326       #line 444 "machine/pentium/disassembler.m"
45327       
45328 
45329               sprintf (str,  "ROLB.Ev.CLow", DIS_EADDR16);
45330 
45331       
45332 
45333       
45334       
45335       
45336     } 
45337     goto MATCH_finished_a; 
45338     
45339   MATCH_label_a587: (void)0; /*placeholder for label*/ 
45340     { 
45341       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45342       nextPC = 3 + MATCH_p; 
45343       
45344       #line 432 "machine/pentium/disassembler.m"
45345       
45346 
45347               sprintf (str,  "RORB.Ev.CLow", DIS_EADDR16);
45348 
45349       
45350 
45351       
45352       
45353       
45354     } 
45355     goto MATCH_finished_a; 
45356     
45357   MATCH_label_a588: (void)0; /*placeholder for label*/ 
45358     { 
45359       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45360       nextPC = 4 + MATCH_p; 
45361       
45362       #line 432 "machine/pentium/disassembler.m"
45363       
45364 
45365               sprintf (str,  "RORB.Ev.CLow", DIS_EADDR16);
45366 
45367       
45368 
45369       
45370       
45371       
45372     } 
45373     goto MATCH_finished_a; 
45374     
45375   MATCH_label_a589: (void)0; /*placeholder for label*/ 
45376     { 
45377       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45378       nextPC = 8 + MATCH_p; 
45379       
45380       #line 432 "machine/pentium/disassembler.m"
45381       
45382 
45383               sprintf (str,  "RORB.Ev.CLow", DIS_EADDR16);
45384 
45385       
45386 
45387       
45388       
45389       
45390     } 
45391     goto MATCH_finished_a; 
45392     
45393   MATCH_label_a590: (void)0; /*placeholder for label*/ 
45394     { 
45395       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45396       nextPC = 7 + MATCH_p; 
45397       
45398       #line 432 "machine/pentium/disassembler.m"
45399       
45400 
45401               sprintf (str,  "RORB.Ev.CLow", DIS_EADDR16);
45402 
45403       
45404 
45405       
45406       
45407       
45408     } 
45409     goto MATCH_finished_a; 
45410     
45411   MATCH_label_a591: (void)0; /*placeholder for label*/ 
45412     { 
45413       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45414       nextPC = 3 + MATCH_p; 
45415       
45416       #line 420 "machine/pentium/disassembler.m"
45417       
45418 
45419               sprintf (str,  "RCLB.Ev.CLow", DIS_EADDR16);
45420 
45421       
45422 
45423       
45424       
45425       
45426     } 
45427     goto MATCH_finished_a; 
45428     
45429   MATCH_label_a592: (void)0; /*placeholder for label*/ 
45430     { 
45431       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45432       nextPC = 4 + MATCH_p; 
45433       
45434       #line 420 "machine/pentium/disassembler.m"
45435       
45436 
45437               sprintf (str,  "RCLB.Ev.CLow", DIS_EADDR16);
45438 
45439       
45440 
45441       
45442       
45443       
45444     } 
45445     goto MATCH_finished_a; 
45446     
45447   MATCH_label_a593: (void)0; /*placeholder for label*/ 
45448     { 
45449       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45450       nextPC = 8 + MATCH_p; 
45451       
45452       #line 420 "machine/pentium/disassembler.m"
45453       
45454 
45455               sprintf (str,  "RCLB.Ev.CLow", DIS_EADDR16);
45456 
45457       
45458 
45459       
45460       
45461       
45462     } 
45463     goto MATCH_finished_a; 
45464     
45465   MATCH_label_a594: (void)0; /*placeholder for label*/ 
45466     { 
45467       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45468       nextPC = 7 + MATCH_p; 
45469       
45470       #line 420 "machine/pentium/disassembler.m"
45471       
45472 
45473               sprintf (str,  "RCLB.Ev.CLow", DIS_EADDR16);
45474 
45475       
45476 
45477       
45478       
45479       
45480     } 
45481     goto MATCH_finished_a; 
45482     
45483   MATCH_label_a595: (void)0; /*placeholder for label*/ 
45484     { 
45485       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45486       nextPC = 3 + MATCH_p; 
45487       
45488       #line 408 "machine/pentium/disassembler.m"
45489       
45490 
45491               sprintf (str,  "RCRB.Ev.CLow", DIS_EADDR16);
45492 
45493       
45494 
45495       
45496       
45497       
45498     } 
45499     goto MATCH_finished_a; 
45500     
45501   MATCH_label_a596: (void)0; /*placeholder for label*/ 
45502     { 
45503       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45504       nextPC = 4 + MATCH_p; 
45505       
45506       #line 408 "machine/pentium/disassembler.m"
45507       
45508 
45509               sprintf (str,  "RCRB.Ev.CLow", DIS_EADDR16);
45510 
45511       
45512 
45513       
45514       
45515       
45516     } 
45517     goto MATCH_finished_a; 
45518     
45519   MATCH_label_a597: (void)0; /*placeholder for label*/ 
45520     { 
45521       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45522       nextPC = 8 + MATCH_p; 
45523       
45524       #line 408 "machine/pentium/disassembler.m"
45525       
45526 
45527               sprintf (str,  "RCRB.Ev.CLow", DIS_EADDR16);
45528 
45529       
45530 
45531       
45532       
45533       
45534     } 
45535     goto MATCH_finished_a; 
45536     
45537   MATCH_label_a598: (void)0; /*placeholder for label*/ 
45538     { 
45539       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45540       nextPC = 7 + MATCH_p; 
45541       
45542       #line 408 "machine/pentium/disassembler.m"
45543       
45544 
45545               sprintf (str,  "RCRB.Ev.CLow", DIS_EADDR16);
45546 
45547       
45548 
45549       
45550       
45551       
45552     } 
45553     goto MATCH_finished_a; 
45554     
45555   MATCH_label_a599: (void)0; /*placeholder for label*/ 
45556     { 
45557       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45558       nextPC = 3 + MATCH_p; 
45559       
45560       #line 396 "machine/pentium/disassembler.m"
45561       
45562 
45563               sprintf (str,  "SHLSALB.Ev.CLow", DIS_EADDR16);
45564 
45565       
45566 
45567       
45568       
45569       
45570     } 
45571     goto MATCH_finished_a; 
45572     
45573   MATCH_label_a600: (void)0; /*placeholder for label*/ 
45574     { 
45575       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45576       nextPC = 4 + MATCH_p; 
45577       
45578       #line 396 "machine/pentium/disassembler.m"
45579       
45580 
45581               sprintf (str,  "SHLSALB.Ev.CLow", DIS_EADDR16);
45582 
45583       
45584 
45585       
45586       
45587       
45588     } 
45589     goto MATCH_finished_a; 
45590     
45591   MATCH_label_a601: (void)0; /*placeholder for label*/ 
45592     { 
45593       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45594       nextPC = 8 + MATCH_p; 
45595       
45596       #line 396 "machine/pentium/disassembler.m"
45597       
45598 
45599               sprintf (str,  "SHLSALB.Ev.CLow", DIS_EADDR16);
45600 
45601       
45602 
45603       
45604       
45605       
45606     } 
45607     goto MATCH_finished_a; 
45608     
45609   MATCH_label_a602: (void)0; /*placeholder for label*/ 
45610     { 
45611       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45612       nextPC = 7 + MATCH_p; 
45613       
45614       #line 396 "machine/pentium/disassembler.m"
45615       
45616 
45617               sprintf (str,  "SHLSALB.Ev.CLow", DIS_EADDR16);
45618 
45619       
45620 
45621       
45622       
45623       
45624     } 
45625     goto MATCH_finished_a; 
45626     
45627   MATCH_label_a603: (void)0; /*placeholder for label*/ 
45628     { 
45629       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45630       nextPC = 3 + MATCH_p; 
45631       
45632       #line 384 "machine/pentium/disassembler.m"
45633       
45634 
45635               sprintf (str,  "SHRB.Ev.CLow", DIS_EADDR16);
45636 
45637       
45638 
45639       
45640       
45641       
45642     } 
45643     goto MATCH_finished_a; 
45644     
45645   MATCH_label_a604: (void)0; /*placeholder for label*/ 
45646     { 
45647       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45648       nextPC = 4 + MATCH_p; 
45649       
45650       #line 384 "machine/pentium/disassembler.m"
45651       
45652 
45653               sprintf (str,  "SHRB.Ev.CLow", DIS_EADDR16);
45654 
45655       
45656 
45657       
45658       
45659       
45660     } 
45661     goto MATCH_finished_a; 
45662     
45663   MATCH_label_a605: (void)0; /*placeholder for label*/ 
45664     { 
45665       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45666       nextPC = 8 + MATCH_p; 
45667       
45668       #line 384 "machine/pentium/disassembler.m"
45669       
45670 
45671               sprintf (str,  "SHRB.Ev.CLow", DIS_EADDR16);
45672 
45673       
45674 
45675       
45676       
45677       
45678     } 
45679     goto MATCH_finished_a; 
45680     
45681   MATCH_label_a606: (void)0; /*placeholder for label*/ 
45682     { 
45683       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45684       nextPC = 7 + MATCH_p; 
45685       
45686       #line 384 "machine/pentium/disassembler.m"
45687       
45688 
45689               sprintf (str,  "SHRB.Ev.CLow", DIS_EADDR16);
45690 
45691       
45692 
45693       
45694       
45695       
45696     } 
45697     goto MATCH_finished_a; 
45698     
45699   MATCH_label_a607: (void)0; /*placeholder for label*/ 
45700     { 
45701       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45702       nextPC = 3 + MATCH_p; 
45703       
45704       #line 372 "machine/pentium/disassembler.m"
45705       
45706 
45707               sprintf (str,  "SARB.Ev.CLow", DIS_EADDR16);
45708 
45709       
45710 
45711       
45712       
45713       
45714     } 
45715     goto MATCH_finished_a; 
45716     
45717   MATCH_label_a608: (void)0; /*placeholder for label*/ 
45718     { 
45719       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45720       nextPC = 4 + MATCH_p; 
45721       
45722       #line 372 "machine/pentium/disassembler.m"
45723       
45724 
45725               sprintf (str,  "SARB.Ev.CLow", DIS_EADDR16);
45726 
45727       
45728 
45729       
45730       
45731       
45732     } 
45733     goto MATCH_finished_a; 
45734     
45735   MATCH_label_a609: (void)0; /*placeholder for label*/ 
45736     { 
45737       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45738       nextPC = 8 + MATCH_p; 
45739       
45740       #line 372 "machine/pentium/disassembler.m"
45741       
45742 
45743               sprintf (str,  "SARB.Ev.CLow", DIS_EADDR16);
45744 
45745       
45746 
45747       
45748       
45749       
45750     } 
45751     goto MATCH_finished_a; 
45752     
45753   MATCH_label_a610: (void)0; /*placeholder for label*/ 
45754     { 
45755       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45756       nextPC = 7 + MATCH_p; 
45757       
45758       #line 372 "machine/pentium/disassembler.m"
45759       
45760 
45761               sprintf (str,  "SARB.Ev.CLow", DIS_EADDR16);
45762 
45763       
45764 
45765       
45766       
45767       
45768     } 
45769     goto MATCH_finished_a; 
45770     
45771   MATCH_label_a611: (void)0; /*placeholder for label*/ 
45772     { 
45773       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45774       unsigned i16 = (MATCH_w_16_24 & 0xffff) /* i16 at 24 */;
45775       nextPC = 5 + MATCH_p; 
45776       
45777       #line 107 "machine/pentium/disassembler.m"
45778       
45779 
45780               sprintf (str,  "TEST.Ew.Iw", DIS_EADDR16, DIS_I16);
45781 
45782       
45783 
45784       
45785       
45786       
45787     } 
45788     goto MATCH_finished_a; 
45789     
45790   MATCH_label_a612: (void)0; /*placeholder for label*/ 
45791     { 
45792       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45793       unsigned i16 = (MATCH_w_16_32 & 0xffff) /* i16 at 32 */;
45794       nextPC = 6 + MATCH_p; 
45795       
45796       #line 107 "machine/pentium/disassembler.m"
45797       
45798 
45799               sprintf (str,  "TEST.Ew.Iw", DIS_EADDR16, DIS_I16);
45800 
45801       
45802 
45803       
45804       
45805       
45806     } 
45807     goto MATCH_finished_a; 
45808     
45809   MATCH_label_a613: (void)0; /*placeholder for label*/ 
45810     { 
45811       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45812       unsigned i16 = (MATCH_w_16_64 & 0xffff) /* i16 at 64 */;
45813       nextPC = 10 + MATCH_p; 
45814       
45815       #line 107 "machine/pentium/disassembler.m"
45816       
45817 
45818               sprintf (str,  "TEST.Ew.Iw", DIS_EADDR16, DIS_I16);
45819 
45820       
45821 
45822       
45823       
45824       
45825     } 
45826     goto MATCH_finished_a; 
45827     
45828   MATCH_label_a614: (void)0; /*placeholder for label*/ 
45829     { 
45830       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45831       unsigned i16 = (MATCH_w_16_56 & 0xffff) /* i16 at 56 */;
45832       nextPC = 9 + MATCH_p; 
45833       
45834       #line 107 "machine/pentium/disassembler.m"
45835       
45836 
45837               sprintf (str,  "TEST.Ew.Iw", DIS_EADDR16, DIS_I16);
45838 
45839       
45840 
45841       
45842       
45843       
45844     } 
45845     goto MATCH_finished_a; 
45846     
45847   MATCH_label_a615: (void)0; /*placeholder for label*/ 
45848     { 
45849       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45850       nextPC = 3 + MATCH_p; 
45851       
45852       #line 618 "machine/pentium/disassembler.m"
45853       
45854 
45855               sprintf (str,  "NOTow", DIS_EADDR16);
45856 
45857       
45858 
45859       
45860       
45861       
45862     } 
45863     goto MATCH_finished_a; 
45864     
45865   MATCH_label_a616: (void)0; /*placeholder for label*/ 
45866     { 
45867       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45868       nextPC = 4 + MATCH_p; 
45869       
45870       #line 618 "machine/pentium/disassembler.m"
45871       
45872 
45873               sprintf (str,  "NOTow", DIS_EADDR16);
45874 
45875       
45876 
45877       
45878       
45879       
45880     } 
45881     goto MATCH_finished_a; 
45882     
45883   MATCH_label_a617: (void)0; /*placeholder for label*/ 
45884     { 
45885       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45886       nextPC = 8 + MATCH_p; 
45887       
45888       #line 618 "machine/pentium/disassembler.m"
45889       
45890 
45891               sprintf (str,  "NOTow", DIS_EADDR16);
45892 
45893       
45894 
45895       
45896       
45897       
45898     } 
45899     goto MATCH_finished_a; 
45900     
45901   MATCH_label_a618: (void)0; /*placeholder for label*/ 
45902     { 
45903       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45904       nextPC = 7 + MATCH_p; 
45905       
45906       #line 618 "machine/pentium/disassembler.m"
45907       
45908 
45909               sprintf (str,  "NOTow", DIS_EADDR16);
45910 
45911       
45912 
45913       
45914       
45915       
45916     } 
45917     goto MATCH_finished_a; 
45918     
45919   MATCH_label_a619: (void)0; /*placeholder for label*/ 
45920     { 
45921       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45922       nextPC = 3 + MATCH_p; 
45923       
45924       #line 627 "machine/pentium/disassembler.m"
45925       
45926 
45927               sprintf (str,  "NEGow", DIS_EADDR16);
45928 
45929       
45930 
45931       
45932       
45933       
45934     } 
45935     goto MATCH_finished_a; 
45936     
45937   MATCH_label_a620: (void)0; /*placeholder for label*/ 
45938     { 
45939       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45940       nextPC = 4 + MATCH_p; 
45941       
45942       #line 627 "machine/pentium/disassembler.m"
45943       
45944 
45945               sprintf (str,  "NEGow", DIS_EADDR16);
45946 
45947       
45948 
45949       
45950       
45951       
45952     } 
45953     goto MATCH_finished_a; 
45954     
45955   MATCH_label_a621: (void)0; /*placeholder for label*/ 
45956     { 
45957       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45958       nextPC = 8 + MATCH_p; 
45959       
45960       #line 627 "machine/pentium/disassembler.m"
45961       
45962 
45963               sprintf (str,  "NEGow", DIS_EADDR16);
45964 
45965       
45966 
45967       
45968       
45969       
45970     } 
45971     goto MATCH_finished_a; 
45972     
45973   MATCH_label_a622: (void)0; /*placeholder for label*/ 
45974     { 
45975       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45976       nextPC = 7 + MATCH_p; 
45977       
45978       #line 627 "machine/pentium/disassembler.m"
45979       
45980 
45981               sprintf (str,  "NEGow", DIS_EADDR16);
45982 
45983       
45984 
45985       
45986       
45987       
45988     } 
45989     goto MATCH_finished_a; 
45990     
45991   MATCH_label_a623: (void)0; /*placeholder for label*/ 
45992     { 
45993       unsigned Eaddr = 2 + addressToPC(MATCH_p);
45994       nextPC = 3 + MATCH_p; 
45995       
45996       #line 636 "machine/pentium/disassembler.m"
45997       
45998 
45999               sprintf (str,  "MUL.AXow", DIS_EADDR16);
46000 
46001       
46002 
46003       
46004       
46005       
46006     } 
46007     goto MATCH_finished_a; 
46008     
46009   MATCH_label_a624: (void)0; /*placeholder for label*/ 
46010     { 
46011       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46012       nextPC = 4 + MATCH_p; 
46013       
46014       #line 636 "machine/pentium/disassembler.m"
46015       
46016 
46017               sprintf (str,  "MUL.AXow", DIS_EADDR16);
46018 
46019       
46020 
46021       
46022       
46023       
46024     } 
46025     goto MATCH_finished_a; 
46026     
46027   MATCH_label_a625: (void)0; /*placeholder for label*/ 
46028     { 
46029       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46030       nextPC = 8 + MATCH_p; 
46031       
46032       #line 636 "machine/pentium/disassembler.m"
46033       
46034 
46035               sprintf (str,  "MUL.AXow", DIS_EADDR16);
46036 
46037       
46038 
46039       
46040       
46041       
46042     } 
46043     goto MATCH_finished_a; 
46044     
46045   MATCH_label_a626: (void)0; /*placeholder for label*/ 
46046     { 
46047       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46048       nextPC = 7 + MATCH_p; 
46049       
46050       #line 636 "machine/pentium/disassembler.m"
46051       
46052 
46053               sprintf (str,  "MUL.AXow", DIS_EADDR16);
46054 
46055       
46056 
46057       
46058       
46059       
46060     } 
46061     goto MATCH_finished_a; 
46062     
46063   MATCH_label_a627: (void)0; /*placeholder for label*/ 
46064     { 
46065       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46066       nextPC = 3 + MATCH_p; 
46067       
46068       #line 878 "machine/pentium/disassembler.m"
46069       
46070 
46071               sprintf (str,  "IMULow", DIS_EADDR16);
46072 
46073       
46074 
46075       
46076       
46077       
46078     } 
46079     goto MATCH_finished_a; 
46080     
46081   MATCH_label_a628: (void)0; /*placeholder for label*/ 
46082     { 
46083       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46084       nextPC = 4 + MATCH_p; 
46085       
46086       #line 878 "machine/pentium/disassembler.m"
46087       
46088 
46089               sprintf (str,  "IMULow", DIS_EADDR16);
46090 
46091       
46092 
46093       
46094       
46095       
46096     } 
46097     goto MATCH_finished_a; 
46098     
46099   MATCH_label_a629: (void)0; /*placeholder for label*/ 
46100     { 
46101       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46102       nextPC = 8 + MATCH_p; 
46103       
46104       #line 878 "machine/pentium/disassembler.m"
46105       
46106 
46107               sprintf (str,  "IMULow", DIS_EADDR16);
46108 
46109       
46110 
46111       
46112       
46113       
46114     } 
46115     goto MATCH_finished_a; 
46116     
46117   MATCH_label_a630: (void)0; /*placeholder for label*/ 
46118     { 
46119       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46120       nextPC = 7 + MATCH_p; 
46121       
46122       #line 878 "machine/pentium/disassembler.m"
46123       
46124 
46125               sprintf (str,  "IMULow", DIS_EADDR16);
46126 
46127       
46128 
46129       
46130       
46131       
46132     } 
46133     goto MATCH_finished_a; 
46134     
46135   MATCH_label_a631: (void)0; /*placeholder for label*/ 
46136     { 
46137       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46138       nextPC = 3 + MATCH_p; 
46139       
46140       #line 902 "machine/pentium/disassembler.m"
46141       
46142 
46143               sprintf (str,  "DIVAX", DIS_EADDR16);
46144 
46145       
46146 
46147       
46148       
46149       
46150     } 
46151     goto MATCH_finished_a; 
46152     
46153   MATCH_label_a632: (void)0; /*placeholder for label*/ 
46154     { 
46155       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46156       nextPC = 4 + MATCH_p; 
46157       
46158       #line 902 "machine/pentium/disassembler.m"
46159       
46160 
46161               sprintf (str,  "DIVAX", DIS_EADDR16);
46162 
46163       
46164 
46165       
46166       
46167       
46168     } 
46169     goto MATCH_finished_a; 
46170     
46171   MATCH_label_a633: (void)0; /*placeholder for label*/ 
46172     { 
46173       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46174       nextPC = 8 + MATCH_p; 
46175       
46176       #line 902 "machine/pentium/disassembler.m"
46177       
46178 
46179               sprintf (str,  "DIVAX", DIS_EADDR16);
46180 
46181       
46182 
46183       
46184       
46185       
46186     } 
46187     goto MATCH_finished_a; 
46188     
46189   MATCH_label_a634: (void)0; /*placeholder for label*/ 
46190     { 
46191       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46192       nextPC = 7 + MATCH_p; 
46193       
46194       #line 902 "machine/pentium/disassembler.m"
46195       
46196 
46197               sprintf (str,  "DIVAX", DIS_EADDR16);
46198 
46199       
46200 
46201       
46202       
46203       
46204     } 
46205     goto MATCH_finished_a; 
46206     
46207   MATCH_label_a635: (void)0; /*placeholder for label*/ 
46208     { 
46209       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46210       nextPC = 3 + MATCH_p; 
46211       
46212       #line 887 "machine/pentium/disassembler.m"
46213       
46214 
46215               sprintf (str,  "IDIVAX", DIS_EADDR16);
46216 
46217       
46218 
46219       
46220       
46221       
46222     } 
46223     goto MATCH_finished_a; 
46224     
46225   MATCH_label_a636: (void)0; /*placeholder for label*/ 
46226     { 
46227       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46228       nextPC = 4 + MATCH_p; 
46229       
46230       #line 887 "machine/pentium/disassembler.m"
46231       
46232 
46233               sprintf (str,  "IDIVAX", DIS_EADDR16);
46234 
46235       
46236 
46237       
46238       
46239       
46240     } 
46241     goto MATCH_finished_a; 
46242     
46243   MATCH_label_a637: (void)0; /*placeholder for label*/ 
46244     { 
46245       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46246       nextPC = 8 + MATCH_p; 
46247       
46248       #line 887 "machine/pentium/disassembler.m"
46249       
46250 
46251               sprintf (str,  "IDIVAX", DIS_EADDR16);
46252 
46253       
46254 
46255       
46256       
46257       
46258     } 
46259     goto MATCH_finished_a; 
46260     
46261   MATCH_label_a638: (void)0; /*placeholder for label*/ 
46262     { 
46263       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46264       nextPC = 7 + MATCH_p; 
46265       
46266       #line 887 "machine/pentium/disassembler.m"
46267       
46268 
46269               sprintf (str,  "IDIVAX", DIS_EADDR16);
46270 
46271       
46272 
46273       
46274       
46275       
46276     } 
46277     goto MATCH_finished_a; 
46278     
46279   MATCH_label_a639: (void)0; /*placeholder for label*/ 
46280     { 
46281       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46282       nextPC = 3 + MATCH_p; 
46283       
46284       #line 833 "machine/pentium/disassembler.m"
46285       
46286 
46287               sprintf (str,  "INC.Evow", DIS_EADDR16);
46288 
46289       
46290 
46291       
46292       
46293       
46294     } 
46295     goto MATCH_finished_a; 
46296     
46297   MATCH_label_a640: (void)0; /*placeholder for label*/ 
46298     { 
46299       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46300       nextPC = 4 + MATCH_p; 
46301       
46302       #line 833 "machine/pentium/disassembler.m"
46303       
46304 
46305               sprintf (str,  "INC.Evow", DIS_EADDR16);
46306 
46307       
46308 
46309       
46310       
46311       
46312     } 
46313     goto MATCH_finished_a; 
46314     
46315   MATCH_label_a641: (void)0; /*placeholder for label*/ 
46316     { 
46317       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46318       nextPC = 8 + MATCH_p; 
46319       
46320       #line 833 "machine/pentium/disassembler.m"
46321       
46322 
46323               sprintf (str,  "INC.Evow", DIS_EADDR16);
46324 
46325       
46326 
46327       
46328       
46329       
46330     } 
46331     goto MATCH_finished_a; 
46332     
46333   MATCH_label_a642: (void)0; /*placeholder for label*/ 
46334     { 
46335       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46336       nextPC = 7 + MATCH_p; 
46337       
46338       #line 833 "machine/pentium/disassembler.m"
46339       
46340 
46341               sprintf (str,  "INC.Evow", DIS_EADDR16);
46342 
46343       
46344 
46345       
46346       
46347       
46348     } 
46349     goto MATCH_finished_a; 
46350     
46351   MATCH_label_a643: (void)0; /*placeholder for label*/ 
46352     { 
46353       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46354       nextPC = 3 + MATCH_p; 
46355       
46356       #line 917 "machine/pentium/disassembler.m"
46357       
46358 
46359               sprintf (str,  "DEC.Evow", DIS_EADDR16);
46360 
46361       
46362 
46363       
46364       
46365       
46366     } 
46367     goto MATCH_finished_a; 
46368     
46369   MATCH_label_a644: (void)0; /*placeholder for label*/ 
46370     { 
46371       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46372       nextPC = 4 + MATCH_p; 
46373       
46374       #line 917 "machine/pentium/disassembler.m"
46375       
46376 
46377               sprintf (str,  "DEC.Evow", DIS_EADDR16);
46378 
46379       
46380 
46381       
46382       
46383       
46384     } 
46385     goto MATCH_finished_a; 
46386     
46387   MATCH_label_a645: (void)0; /*placeholder for label*/ 
46388     { 
46389       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46390       nextPC = 8 + MATCH_p; 
46391       
46392       #line 917 "machine/pentium/disassembler.m"
46393       
46394 
46395               sprintf (str,  "DEC.Evow", DIS_EADDR16);
46396 
46397       
46398 
46399       
46400       
46401       
46402     } 
46403     goto MATCH_finished_a; 
46404     
46405   MATCH_label_a646: (void)0; /*placeholder for label*/ 
46406     { 
46407       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46408       nextPC = 7 + MATCH_p; 
46409       
46410       #line 917 "machine/pentium/disassembler.m"
46411       
46412 
46413               sprintf (str,  "DEC.Evow", DIS_EADDR16);
46414 
46415       
46416 
46417       
46418       
46419       
46420     } 
46421     goto MATCH_finished_a; 
46422     
46423   MATCH_label_a647: (void)0; /*placeholder for label*/ 
46424     { 
46425       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46426       nextPC = 3 + MATCH_p; 
46427       
46428       #line 546 "machine/pentium/disassembler.m"
46429       
46430 
46431               sprintf (str,  "PUSH.Evow", DIS_EADDR16);
46432 
46433       
46434 
46435       
46436       
46437       
46438     } 
46439     goto MATCH_finished_a; 
46440     
46441   MATCH_label_a648: (void)0; /*placeholder for label*/ 
46442     { 
46443       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46444       nextPC = 4 + MATCH_p; 
46445       
46446       #line 546 "machine/pentium/disassembler.m"
46447       
46448 
46449               sprintf (str,  "PUSH.Evow", DIS_EADDR16);
46450 
46451       
46452 
46453       
46454       
46455       
46456     } 
46457     goto MATCH_finished_a; 
46458     
46459   MATCH_label_a649: (void)0; /*placeholder for label*/ 
46460     { 
46461       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46462       nextPC = 8 + MATCH_p; 
46463       
46464       #line 546 "machine/pentium/disassembler.m"
46465       
46466 
46467               sprintf (str,  "PUSH.Evow", DIS_EADDR16);
46468 
46469       
46470 
46471       
46472       
46473       
46474     } 
46475     goto MATCH_finished_a; 
46476     
46477   MATCH_label_a650: (void)0; /*placeholder for label*/ 
46478     { 
46479       unsigned Eaddr = 2 + addressToPC(MATCH_p);
46480       nextPC = 7 + MATCH_p; 
46481       
46482       #line 546 "machine/pentium/disassembler.m"
46483       
46484 
46485               sprintf (str,  "PUSH.Evow", DIS_EADDR16);
46486 
46487       
46488 
46489       
46490       
46491       
46492     } 
46493     goto MATCH_finished_a; 
46494     
46495   MATCH_label_a651: (void)0; /*placeholder for label*/ 
46496     { 
46497       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46498       int /* [~128..127] */ i8 = 
46499         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
46500       nextPC = 3 + MATCH_p; 
46501       
46502       #line 1339 "machine/pentium/disassembler.m"
46503       
46504 
46505               sprintf (str,  "ADDib", DIS_EADDR8, DIS_I8);
46506 
46507       
46508 
46509       
46510       
46511       
46512     } 
46513     goto MATCH_finished_a; 
46514     
46515   MATCH_label_a652: (void)0; /*placeholder for label*/ 
46516     { 
46517       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46518       int /* [~128..127] */ i8 = 
46519         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
46520       nextPC = 4 + MATCH_p; 
46521       
46522       #line 1339 "machine/pentium/disassembler.m"
46523       
46524 
46525               sprintf (str,  "ADDib", DIS_EADDR8, DIS_I8);
46526 
46527       
46528 
46529       
46530       
46531       
46532     } 
46533     goto MATCH_finished_a; 
46534     
46535   MATCH_label_a653: (void)0; /*placeholder for label*/ 
46536     { 
46537       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46538       int /* [~128..127] */ i8 = 
46539         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
46540       nextPC = 8 + MATCH_p; 
46541       
46542       #line 1339 "machine/pentium/disassembler.m"
46543       
46544 
46545               sprintf (str,  "ADDib", DIS_EADDR8, DIS_I8);
46546 
46547       
46548 
46549       
46550       
46551       
46552     } 
46553     goto MATCH_finished_a; 
46554     
46555   MATCH_label_a654: (void)0; /*placeholder for label*/ 
46556     { 
46557       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46558       int /* [~128..127] */ i8 = 
46559         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
46560       nextPC = 7 + MATCH_p; 
46561       
46562       #line 1339 "machine/pentium/disassembler.m"
46563       
46564 
46565               sprintf (str,  "ADDib", DIS_EADDR8, DIS_I8);
46566 
46567       
46568 
46569       
46570       
46571       
46572     } 
46573     goto MATCH_finished_a; 
46574     
46575   MATCH_label_a655: (void)0; /*placeholder for label*/ 
46576     { 
46577       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46578       int /* [~128..127] */ i8 = 
46579         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
46580       nextPC = 3 + MATCH_p; 
46581       
46582       #line 1336 "machine/pentium/disassembler.m"
46583       
46584 
46585               sprintf (str,  "ORib", DIS_EADDR8, DIS_I8);
46586 
46587       
46588 
46589       
46590       
46591       
46592     } 
46593     goto MATCH_finished_a; 
46594     
46595   MATCH_label_a656: (void)0; /*placeholder for label*/ 
46596     { 
46597       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46598       int /* [~128..127] */ i8 = 
46599         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
46600       nextPC = 4 + MATCH_p; 
46601       
46602       #line 1336 "machine/pentium/disassembler.m"
46603       
46604 
46605               sprintf (str,  "ORib", DIS_EADDR8, DIS_I8);
46606 
46607       
46608 
46609       
46610       
46611       
46612     } 
46613     goto MATCH_finished_a; 
46614     
46615   MATCH_label_a657: (void)0; /*placeholder for label*/ 
46616     { 
46617       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46618       int /* [~128..127] */ i8 = 
46619         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
46620       nextPC = 8 + MATCH_p; 
46621       
46622       #line 1336 "machine/pentium/disassembler.m"
46623       
46624 
46625               sprintf (str,  "ORib", DIS_EADDR8, DIS_I8);
46626 
46627       
46628 
46629       
46630       
46631       
46632     } 
46633     goto MATCH_finished_a; 
46634     
46635   MATCH_label_a658: (void)0; /*placeholder for label*/ 
46636     { 
46637       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46638       int /* [~128..127] */ i8 = 
46639         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
46640       nextPC = 7 + MATCH_p; 
46641       
46642       #line 1336 "machine/pentium/disassembler.m"
46643       
46644 
46645               sprintf (str,  "ORib", DIS_EADDR8, DIS_I8);
46646 
46647       
46648 
46649       
46650       
46651       
46652     } 
46653     goto MATCH_finished_a; 
46654     
46655   MATCH_label_a659: (void)0; /*placeholder for label*/ 
46656     { 
46657       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46658       int /* [~128..127] */ i8 = 
46659         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
46660       nextPC = 3 + MATCH_p; 
46661       
46662       #line 1333 "machine/pentium/disassembler.m"
46663       
46664 
46665               sprintf (str,  "ADCib", DIS_EADDR8, DIS_I8);
46666 
46667       
46668 
46669       
46670       
46671       
46672     } 
46673     goto MATCH_finished_a; 
46674     
46675   MATCH_label_a660: (void)0; /*placeholder for label*/ 
46676     { 
46677       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46678       int /* [~128..127] */ i8 = 
46679         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
46680       nextPC = 4 + MATCH_p; 
46681       
46682       #line 1333 "machine/pentium/disassembler.m"
46683       
46684 
46685               sprintf (str,  "ADCib", DIS_EADDR8, DIS_I8);
46686 
46687       
46688 
46689       
46690       
46691       
46692     } 
46693     goto MATCH_finished_a; 
46694     
46695   MATCH_label_a661: (void)0; /*placeholder for label*/ 
46696     { 
46697       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46698       int /* [~128..127] */ i8 = 
46699         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
46700       nextPC = 8 + MATCH_p; 
46701       
46702       #line 1333 "machine/pentium/disassembler.m"
46703       
46704 
46705               sprintf (str,  "ADCib", DIS_EADDR8, DIS_I8);
46706 
46707       
46708 
46709       
46710       
46711       
46712     } 
46713     goto MATCH_finished_a; 
46714     
46715   MATCH_label_a662: (void)0; /*placeholder for label*/ 
46716     { 
46717       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46718       int /* [~128..127] */ i8 = 
46719         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
46720       nextPC = 7 + MATCH_p; 
46721       
46722       #line 1333 "machine/pentium/disassembler.m"
46723       
46724 
46725               sprintf (str,  "ADCib", DIS_EADDR8, DIS_I8);
46726 
46727       
46728 
46729       
46730       
46731       
46732     } 
46733     goto MATCH_finished_a; 
46734     
46735   MATCH_label_a663: (void)0; /*placeholder for label*/ 
46736     { 
46737       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46738       int /* [~128..127] */ i8 = 
46739         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
46740       nextPC = 3 + MATCH_p; 
46741       
46742       #line 1330 "machine/pentium/disassembler.m"
46743       
46744 
46745               sprintf (str,  "SBBib", DIS_EADDR8, DIS_I8);
46746 
46747       
46748 
46749       
46750       
46751       
46752     } 
46753     goto MATCH_finished_a; 
46754     
46755   MATCH_label_a664: (void)0; /*placeholder for label*/ 
46756     { 
46757       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46758       int /* [~128..127] */ i8 = 
46759         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
46760       nextPC = 4 + MATCH_p; 
46761       
46762       #line 1330 "machine/pentium/disassembler.m"
46763       
46764 
46765               sprintf (str,  "SBBib", DIS_EADDR8, DIS_I8);
46766 
46767       
46768 
46769       
46770       
46771       
46772     } 
46773     goto MATCH_finished_a; 
46774     
46775   MATCH_label_a665: (void)0; /*placeholder for label*/ 
46776     { 
46777       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46778       int /* [~128..127] */ i8 = 
46779         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
46780       nextPC = 8 + MATCH_p; 
46781       
46782       #line 1330 "machine/pentium/disassembler.m"
46783       
46784 
46785               sprintf (str,  "SBBib", DIS_EADDR8, DIS_I8);
46786 
46787       
46788 
46789       
46790       
46791       
46792     } 
46793     goto MATCH_finished_a; 
46794     
46795   MATCH_label_a666: (void)0; /*placeholder for label*/ 
46796     { 
46797       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46798       int /* [~128..127] */ i8 = 
46799         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
46800       nextPC = 7 + MATCH_p; 
46801       
46802       #line 1330 "machine/pentium/disassembler.m"
46803       
46804 
46805               sprintf (str,  "SBBib", DIS_EADDR8, DIS_I8);
46806 
46807       
46808 
46809       
46810       
46811       
46812     } 
46813     goto MATCH_finished_a; 
46814     
46815   MATCH_label_a667: (void)0; /*placeholder for label*/ 
46816     { 
46817       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46818       int /* [~128..127] */ i8 = 
46819         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
46820       nextPC = 3 + MATCH_p; 
46821       
46822       #line 1327 "machine/pentium/disassembler.m"
46823       
46824 
46825               sprintf (str,  "ANDib", DIS_EADDR8, DIS_I8);
46826 
46827       
46828 
46829       
46830       
46831       
46832     } 
46833     goto MATCH_finished_a; 
46834     
46835   MATCH_label_a668: (void)0; /*placeholder for label*/ 
46836     { 
46837       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46838       int /* [~128..127] */ i8 = 
46839         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
46840       nextPC = 4 + MATCH_p; 
46841       
46842       #line 1327 "machine/pentium/disassembler.m"
46843       
46844 
46845               sprintf (str,  "ANDib", DIS_EADDR8, DIS_I8);
46846 
46847       
46848 
46849       
46850       
46851       
46852     } 
46853     goto MATCH_finished_a; 
46854     
46855   MATCH_label_a669: (void)0; /*placeholder for label*/ 
46856     { 
46857       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46858       int /* [~128..127] */ i8 = 
46859         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
46860       nextPC = 8 + MATCH_p; 
46861       
46862       #line 1327 "machine/pentium/disassembler.m"
46863       
46864 
46865               sprintf (str,  "ANDib", DIS_EADDR8, DIS_I8);
46866 
46867       
46868 
46869       
46870       
46871       
46872     } 
46873     goto MATCH_finished_a; 
46874     
46875   MATCH_label_a670: (void)0; /*placeholder for label*/ 
46876     { 
46877       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46878       int /* [~128..127] */ i8 = 
46879         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
46880       nextPC = 7 + MATCH_p; 
46881       
46882       #line 1327 "machine/pentium/disassembler.m"
46883       
46884 
46885               sprintf (str,  "ANDib", DIS_EADDR8, DIS_I8);
46886 
46887       
46888 
46889       
46890       
46891       
46892     } 
46893     goto MATCH_finished_a; 
46894     
46895   MATCH_label_a671: (void)0; /*placeholder for label*/ 
46896     { 
46897       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46898       int /* [~128..127] */ i8 = 
46899         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
46900       nextPC = 3 + MATCH_p; 
46901       
46902       #line 1324 "machine/pentium/disassembler.m"
46903       
46904 
46905               sprintf (str,  "SUBib", DIS_EADDR8, DIS_I8);
46906 
46907       
46908 
46909       
46910       
46911       
46912     } 
46913     goto MATCH_finished_a; 
46914     
46915   MATCH_label_a672: (void)0; /*placeholder for label*/ 
46916     { 
46917       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46918       int /* [~128..127] */ i8 = 
46919         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
46920       nextPC = 4 + MATCH_p; 
46921       
46922       #line 1324 "machine/pentium/disassembler.m"
46923       
46924 
46925               sprintf (str,  "SUBib", DIS_EADDR8, DIS_I8);
46926 
46927       
46928 
46929       
46930       
46931       
46932     } 
46933     goto MATCH_finished_a; 
46934     
46935   MATCH_label_a673: (void)0; /*placeholder for label*/ 
46936     { 
46937       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46938       int /* [~128..127] */ i8 = 
46939         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
46940       nextPC = 8 + MATCH_p; 
46941       
46942       #line 1324 "machine/pentium/disassembler.m"
46943       
46944 
46945               sprintf (str,  "SUBib", DIS_EADDR8, DIS_I8);
46946 
46947       
46948 
46949       
46950       
46951       
46952     } 
46953     goto MATCH_finished_a; 
46954     
46955   MATCH_label_a674: (void)0; /*placeholder for label*/ 
46956     { 
46957       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46958       int /* [~128..127] */ i8 = 
46959         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
46960       nextPC = 7 + MATCH_p; 
46961       
46962       #line 1324 "machine/pentium/disassembler.m"
46963       
46964 
46965               sprintf (str,  "SUBib", DIS_EADDR8, DIS_I8);
46966 
46967       
46968 
46969       
46970       
46971       
46972     } 
46973     goto MATCH_finished_a; 
46974     
46975   MATCH_label_a675: (void)0; /*placeholder for label*/ 
46976     { 
46977       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46978       int /* [~128..127] */ i8 = 
46979         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
46980       nextPC = 3 + MATCH_p; 
46981       
46982       #line 1321 "machine/pentium/disassembler.m"
46983       
46984 
46985               sprintf (str,  "XORib", DIS_EADDR8, DIS_I8);
46986 
46987       
46988 
46989       
46990       
46991       
46992     } 
46993     goto MATCH_finished_a; 
46994     
46995   MATCH_label_a676: (void)0; /*placeholder for label*/ 
46996     { 
46997       unsigned Eaddr = 1 + addressToPC(MATCH_p);
46998       int /* [~128..127] */ i8 = 
46999         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
47000       nextPC = 4 + MATCH_p; 
47001       
47002       #line 1321 "machine/pentium/disassembler.m"
47003       
47004 
47005               sprintf (str,  "XORib", DIS_EADDR8, DIS_I8);
47006 
47007       
47008 
47009       
47010       
47011       
47012     } 
47013     goto MATCH_finished_a; 
47014     
47015   MATCH_label_a677: (void)0; /*placeholder for label*/ 
47016     { 
47017       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47018       int /* [~128..127] */ i8 = 
47019         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
47020       nextPC = 8 + MATCH_p; 
47021       
47022       #line 1321 "machine/pentium/disassembler.m"
47023       
47024 
47025               sprintf (str,  "XORib", DIS_EADDR8, DIS_I8);
47026 
47027       
47028 
47029       
47030       
47031       
47032     } 
47033     goto MATCH_finished_a; 
47034     
47035   MATCH_label_a678: (void)0; /*placeholder for label*/ 
47036     { 
47037       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47038       int /* [~128..127] */ i8 = 
47039         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
47040       nextPC = 7 + MATCH_p; 
47041       
47042       #line 1321 "machine/pentium/disassembler.m"
47043       
47044 
47045               sprintf (str,  "XORib", DIS_EADDR8, DIS_I8);
47046 
47047       
47048 
47049       
47050       
47051       
47052     } 
47053     goto MATCH_finished_a; 
47054     
47055   MATCH_label_a679: (void)0; /*placeholder for label*/ 
47056     { 
47057       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47058       int /* [~128..127] */ i8 = 
47059         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
47060       nextPC = 3 + MATCH_p; 
47061       
47062       #line 1318 "machine/pentium/disassembler.m"
47063       
47064 
47065               sprintf (str,  "CMPib", DIS_EADDR8, DIS_I8);
47066 
47067       
47068 
47069       
47070       
47071       
47072     } 
47073     goto MATCH_finished_a; 
47074     
47075   MATCH_label_a680: (void)0; /*placeholder for label*/ 
47076     { 
47077       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47078       int /* [~128..127] */ i8 = 
47079         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
47080       nextPC = 4 + MATCH_p; 
47081       
47082       #line 1318 "machine/pentium/disassembler.m"
47083       
47084 
47085               sprintf (str,  "CMPib", DIS_EADDR8, DIS_I8);
47086 
47087       
47088 
47089       
47090       
47091       
47092     } 
47093     goto MATCH_finished_a; 
47094     
47095   MATCH_label_a681: (void)0; /*placeholder for label*/ 
47096     { 
47097       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47098       int /* [~128..127] */ i8 = 
47099         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
47100       nextPC = 8 + MATCH_p; 
47101       
47102       #line 1318 "machine/pentium/disassembler.m"
47103       
47104 
47105               sprintf (str,  "CMPib", DIS_EADDR8, DIS_I8);
47106 
47107       
47108 
47109       
47110       
47111       
47112     } 
47113     goto MATCH_finished_a; 
47114     
47115   MATCH_label_a682: (void)0; /*placeholder for label*/ 
47116     { 
47117       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47118       int /* [~128..127] */ i8 = 
47119         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
47120       nextPC = 7 + MATCH_p; 
47121       
47122       #line 1318 "machine/pentium/disassembler.m"
47123       
47124 
47125               sprintf (str,  "CMPib", DIS_EADDR8, DIS_I8);
47126 
47127       
47128 
47129       
47130       
47131       
47132     } 
47133     goto MATCH_finished_a; 
47134     
47135   MATCH_label_a683: (void)0; /*placeholder for label*/ 
47136     { 
47137       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47138       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
47139       nextPC = 6 + MATCH_p; 
47140       
47141       #line 1291 "machine/pentium/disassembler.m"
47142       
47143 
47144               sprintf (str,  "ADDid", DIS_EADDR32, DIS_I32);
47145 
47146       
47147 
47148       
47149       
47150       
47151     } 
47152     goto MATCH_finished_a; 
47153     
47154   MATCH_label_a684: (void)0; /*placeholder for label*/ 
47155     { 
47156       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47157       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
47158       nextPC = 7 + MATCH_p; 
47159       
47160       #line 1291 "machine/pentium/disassembler.m"
47161       
47162 
47163               sprintf (str,  "ADDid", DIS_EADDR32, DIS_I32);
47164 
47165       
47166 
47167       
47168       
47169       
47170     } 
47171     goto MATCH_finished_a; 
47172     
47173   MATCH_label_a685: (void)0; /*placeholder for label*/ 
47174     { 
47175       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47176       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
47177       nextPC = 11 + MATCH_p; 
47178       
47179       #line 1291 "machine/pentium/disassembler.m"
47180       
47181 
47182               sprintf (str,  "ADDid", DIS_EADDR32, DIS_I32);
47183 
47184       
47185 
47186       
47187       
47188       
47189     } 
47190     goto MATCH_finished_a; 
47191     
47192   MATCH_label_a686: (void)0; /*placeholder for label*/ 
47193     { 
47194       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47195       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
47196       nextPC = 10 + MATCH_p; 
47197       
47198       #line 1291 "machine/pentium/disassembler.m"
47199       
47200 
47201               sprintf (str,  "ADDid", DIS_EADDR32, DIS_I32);
47202 
47203       
47204 
47205       
47206       
47207       
47208     } 
47209     goto MATCH_finished_a; 
47210     
47211   MATCH_label_a687: (void)0; /*placeholder for label*/ 
47212     { 
47213       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47214       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
47215       nextPC = 6 + MATCH_p; 
47216       
47217       #line 1288 "machine/pentium/disassembler.m"
47218       
47219 
47220               sprintf (str,  "ORid", DIS_EADDR32, DIS_I32);
47221 
47222       
47223 
47224       
47225       
47226       
47227     } 
47228     goto MATCH_finished_a; 
47229     
47230   MATCH_label_a688: (void)0; /*placeholder for label*/ 
47231     { 
47232       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47233       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
47234       nextPC = 7 + MATCH_p; 
47235       
47236       #line 1288 "machine/pentium/disassembler.m"
47237       
47238 
47239               sprintf (str,  "ORid", DIS_EADDR32, DIS_I32);
47240 
47241       
47242 
47243       
47244       
47245       
47246     } 
47247     goto MATCH_finished_a; 
47248     
47249   MATCH_label_a689: (void)0; /*placeholder for label*/ 
47250     { 
47251       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47252       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
47253       nextPC = 11 + MATCH_p; 
47254       
47255       #line 1288 "machine/pentium/disassembler.m"
47256       
47257 
47258               sprintf (str,  "ORid", DIS_EADDR32, DIS_I32);
47259 
47260       
47261 
47262       
47263       
47264       
47265     } 
47266     goto MATCH_finished_a; 
47267     
47268   MATCH_label_a690: (void)0; /*placeholder for label*/ 
47269     { 
47270       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47271       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
47272       nextPC = 10 + MATCH_p; 
47273       
47274       #line 1288 "machine/pentium/disassembler.m"
47275       
47276 
47277               sprintf (str,  "ORid", DIS_EADDR32, DIS_I32);
47278 
47279       
47280 
47281       
47282       
47283       
47284     } 
47285     goto MATCH_finished_a; 
47286     
47287   MATCH_label_a691: (void)0; /*placeholder for label*/ 
47288     { 
47289       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47290       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
47291       nextPC = 6 + MATCH_p; 
47292       
47293       #line 1285 "machine/pentium/disassembler.m"
47294       
47295 
47296               sprintf (str,  "ADCid", DIS_EADDR32, DIS_I32);
47297 
47298       
47299 
47300       
47301       
47302       
47303     } 
47304     goto MATCH_finished_a; 
47305     
47306   MATCH_label_a692: (void)0; /*placeholder for label*/ 
47307     { 
47308       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47309       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
47310       nextPC = 7 + MATCH_p; 
47311       
47312       #line 1285 "machine/pentium/disassembler.m"
47313       
47314 
47315               sprintf (str,  "ADCid", DIS_EADDR32, DIS_I32);
47316 
47317       
47318 
47319       
47320       
47321       
47322     } 
47323     goto MATCH_finished_a; 
47324     
47325   MATCH_label_a693: (void)0; /*placeholder for label*/ 
47326     { 
47327       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47328       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
47329       nextPC = 11 + MATCH_p; 
47330       
47331       #line 1285 "machine/pentium/disassembler.m"
47332       
47333 
47334               sprintf (str,  "ADCid", DIS_EADDR32, DIS_I32);
47335 
47336       
47337 
47338       
47339       
47340       
47341     } 
47342     goto MATCH_finished_a; 
47343     
47344   MATCH_label_a694: (void)0; /*placeholder for label*/ 
47345     { 
47346       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47347       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
47348       nextPC = 10 + MATCH_p; 
47349       
47350       #line 1285 "machine/pentium/disassembler.m"
47351       
47352 
47353               sprintf (str,  "ADCid", DIS_EADDR32, DIS_I32);
47354 
47355       
47356 
47357       
47358       
47359       
47360     } 
47361     goto MATCH_finished_a; 
47362     
47363   MATCH_label_a695: (void)0; /*placeholder for label*/ 
47364     { 
47365       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47366       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
47367       nextPC = 6 + MATCH_p; 
47368       
47369       #line 1282 "machine/pentium/disassembler.m"
47370       
47371 
47372               sprintf (str,  "SBBid", DIS_EADDR32, DIS_I32);
47373 
47374       
47375 
47376       
47377       
47378       
47379     } 
47380     goto MATCH_finished_a; 
47381     
47382   MATCH_label_a696: (void)0; /*placeholder for label*/ 
47383     { 
47384       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47385       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
47386       nextPC = 7 + MATCH_p; 
47387       
47388       #line 1282 "machine/pentium/disassembler.m"
47389       
47390 
47391               sprintf (str,  "SBBid", DIS_EADDR32, DIS_I32);
47392 
47393       
47394 
47395       
47396       
47397       
47398     } 
47399     goto MATCH_finished_a; 
47400     
47401   MATCH_label_a697: (void)0; /*placeholder for label*/ 
47402     { 
47403       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47404       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
47405       nextPC = 11 + MATCH_p; 
47406       
47407       #line 1282 "machine/pentium/disassembler.m"
47408       
47409 
47410               sprintf (str,  "SBBid", DIS_EADDR32, DIS_I32);
47411 
47412       
47413 
47414       
47415       
47416       
47417     } 
47418     goto MATCH_finished_a; 
47419     
47420   MATCH_label_a698: (void)0; /*placeholder for label*/ 
47421     { 
47422       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47423       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
47424       nextPC = 10 + MATCH_p; 
47425       
47426       #line 1282 "machine/pentium/disassembler.m"
47427       
47428 
47429               sprintf (str,  "SBBid", DIS_EADDR32, DIS_I32);
47430 
47431       
47432 
47433       
47434       
47435       
47436     } 
47437     goto MATCH_finished_a; 
47438     
47439   MATCH_label_a699: (void)0; /*placeholder for label*/ 
47440     { 
47441       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47442       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
47443       nextPC = 6 + MATCH_p; 
47444       
47445       #line 1279 "machine/pentium/disassembler.m"
47446       
47447 
47448               sprintf (str,  "ANDid", DIS_EADDR32, DIS_I32);
47449 
47450       
47451 
47452       
47453       
47454       
47455     } 
47456     goto MATCH_finished_a; 
47457     
47458   MATCH_label_a700: (void)0; /*placeholder for label*/ 
47459     { 
47460       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47461       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
47462       nextPC = 7 + MATCH_p; 
47463       
47464       #line 1279 "machine/pentium/disassembler.m"
47465       
47466 
47467               sprintf (str,  "ANDid", DIS_EADDR32, DIS_I32);
47468 
47469       
47470 
47471       
47472       
47473       
47474     } 
47475     goto MATCH_finished_a; 
47476     
47477   MATCH_label_a701: (void)0; /*placeholder for label*/ 
47478     { 
47479       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47480       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
47481       nextPC = 11 + MATCH_p; 
47482       
47483       #line 1279 "machine/pentium/disassembler.m"
47484       
47485 
47486               sprintf (str,  "ANDid", DIS_EADDR32, DIS_I32);
47487 
47488       
47489 
47490       
47491       
47492       
47493     } 
47494     goto MATCH_finished_a; 
47495     
47496   MATCH_label_a702: (void)0; /*placeholder for label*/ 
47497     { 
47498       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47499       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
47500       nextPC = 10 + MATCH_p; 
47501       
47502       #line 1279 "machine/pentium/disassembler.m"
47503       
47504 
47505               sprintf (str,  "ANDid", DIS_EADDR32, DIS_I32);
47506 
47507       
47508 
47509       
47510       
47511       
47512     } 
47513     goto MATCH_finished_a; 
47514     
47515   MATCH_label_a703: (void)0; /*placeholder for label*/ 
47516     { 
47517       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47518       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
47519       nextPC = 6 + MATCH_p; 
47520       
47521       #line 1276 "machine/pentium/disassembler.m"
47522       
47523 
47524               sprintf (str,  "SUBid", DIS_EADDR32, DIS_I32);
47525 
47526       
47527 
47528       
47529       
47530       
47531     } 
47532     goto MATCH_finished_a; 
47533     
47534   MATCH_label_a704: (void)0; /*placeholder for label*/ 
47535     { 
47536       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47537       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
47538       nextPC = 7 + MATCH_p; 
47539       
47540       #line 1276 "machine/pentium/disassembler.m"
47541       
47542 
47543               sprintf (str,  "SUBid", DIS_EADDR32, DIS_I32);
47544 
47545       
47546 
47547       
47548       
47549       
47550     } 
47551     goto MATCH_finished_a; 
47552     
47553   MATCH_label_a705: (void)0; /*placeholder for label*/ 
47554     { 
47555       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47556       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
47557       nextPC = 11 + MATCH_p; 
47558       
47559       #line 1276 "machine/pentium/disassembler.m"
47560       
47561 
47562               sprintf (str,  "SUBid", DIS_EADDR32, DIS_I32);
47563 
47564       
47565 
47566       
47567       
47568       
47569     } 
47570     goto MATCH_finished_a; 
47571     
47572   MATCH_label_a706: (void)0; /*placeholder for label*/ 
47573     { 
47574       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47575       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
47576       nextPC = 10 + MATCH_p; 
47577       
47578       #line 1276 "machine/pentium/disassembler.m"
47579       
47580 
47581               sprintf (str,  "SUBid", DIS_EADDR32, DIS_I32);
47582 
47583       
47584 
47585       
47586       
47587       
47588     } 
47589     goto MATCH_finished_a; 
47590     
47591   MATCH_label_a707: (void)0; /*placeholder for label*/ 
47592     { 
47593       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47594       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
47595       nextPC = 6 + MATCH_p; 
47596       
47597       #line 1273 "machine/pentium/disassembler.m"
47598       
47599 
47600               sprintf (str,  "XORid", DIS_EADDR32, DIS_I32);
47601 
47602       
47603 
47604       
47605       
47606       
47607     } 
47608     goto MATCH_finished_a; 
47609     
47610   MATCH_label_a708: (void)0; /*placeholder for label*/ 
47611     { 
47612       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47613       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
47614       nextPC = 7 + MATCH_p; 
47615       
47616       #line 1273 "machine/pentium/disassembler.m"
47617       
47618 
47619               sprintf (str,  "XORid", DIS_EADDR32, DIS_I32);
47620 
47621       
47622 
47623       
47624       
47625       
47626     } 
47627     goto MATCH_finished_a; 
47628     
47629   MATCH_label_a709: (void)0; /*placeholder for label*/ 
47630     { 
47631       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47632       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
47633       nextPC = 11 + MATCH_p; 
47634       
47635       #line 1273 "machine/pentium/disassembler.m"
47636       
47637 
47638               sprintf (str,  "XORid", DIS_EADDR32, DIS_I32);
47639 
47640       
47641 
47642       
47643       
47644       
47645     } 
47646     goto MATCH_finished_a; 
47647     
47648   MATCH_label_a710: (void)0; /*placeholder for label*/ 
47649     { 
47650       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47651       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
47652       nextPC = 10 + MATCH_p; 
47653       
47654       #line 1273 "machine/pentium/disassembler.m"
47655       
47656 
47657               sprintf (str,  "XORid", DIS_EADDR32, DIS_I32);
47658 
47659       
47660 
47661       
47662       
47663       
47664     } 
47665     goto MATCH_finished_a; 
47666     
47667   MATCH_label_a711: (void)0; /*placeholder for label*/ 
47668     { 
47669       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47670       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
47671       nextPC = 6 + MATCH_p; 
47672       
47673       #line 1270 "machine/pentium/disassembler.m"
47674       
47675 
47676               sprintf (str,  "CMPid", DIS_EADDR32, DIS_I32);
47677 
47678       
47679 
47680       
47681       
47682       
47683     } 
47684     goto MATCH_finished_a; 
47685     
47686   MATCH_label_a712: (void)0; /*placeholder for label*/ 
47687     { 
47688       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47689       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
47690       nextPC = 7 + MATCH_p; 
47691       
47692       #line 1270 "machine/pentium/disassembler.m"
47693       
47694 
47695               sprintf (str,  "CMPid", DIS_EADDR32, DIS_I32);
47696 
47697       
47698 
47699       
47700       
47701       
47702     } 
47703     goto MATCH_finished_a; 
47704     
47705   MATCH_label_a713: (void)0; /*placeholder for label*/ 
47706     { 
47707       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47708       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
47709       nextPC = 11 + MATCH_p; 
47710       
47711       #line 1270 "machine/pentium/disassembler.m"
47712       
47713 
47714               sprintf (str,  "CMPid", DIS_EADDR32, DIS_I32);
47715 
47716       
47717 
47718       
47719       
47720       
47721     } 
47722     goto MATCH_finished_a; 
47723     
47724   MATCH_label_a714: (void)0; /*placeholder for label*/ 
47725     { 
47726       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47727       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
47728       nextPC = 10 + MATCH_p; 
47729       
47730       #line 1270 "machine/pentium/disassembler.m"
47731       
47732 
47733               sprintf (str,  "CMPid", DIS_EADDR32, DIS_I32);
47734 
47735       
47736 
47737       
47738       
47739       
47740     } 
47741     goto MATCH_finished_a; 
47742     
47743   MATCH_label_a715: (void)0; /*placeholder for label*/ 
47744     { 
47745       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47746       int /* [~128..127] */ i8 = 
47747         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
47748       nextPC = 3 + MATCH_p; 
47749       
47750       #line 1264 "machine/pentium/disassembler.m"
47751       
47752 
47753               sprintf (str,  "ADDiodb", DIS_EADDR32, DIS_I8);
47754 
47755       
47756 
47757       
47758       
47759       
47760     } 
47761     goto MATCH_finished_a; 
47762     
47763   MATCH_label_a716: (void)0; /*placeholder for label*/ 
47764     { 
47765       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47766       int /* [~128..127] */ i8 = 
47767         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
47768       nextPC = 4 + MATCH_p; 
47769       
47770       #line 1264 "machine/pentium/disassembler.m"
47771       
47772 
47773               sprintf (str,  "ADDiodb", DIS_EADDR32, DIS_I8);
47774 
47775       
47776 
47777       
47778       
47779       
47780     } 
47781     goto MATCH_finished_a; 
47782     
47783   MATCH_label_a717: (void)0; /*placeholder for label*/ 
47784     { 
47785       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47786       int /* [~128..127] */ i8 = 
47787         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
47788       nextPC = 8 + MATCH_p; 
47789       
47790       #line 1264 "machine/pentium/disassembler.m"
47791       
47792 
47793               sprintf (str,  "ADDiodb", DIS_EADDR32, DIS_I8);
47794 
47795       
47796 
47797       
47798       
47799       
47800     } 
47801     goto MATCH_finished_a; 
47802     
47803   MATCH_label_a718: (void)0; /*placeholder for label*/ 
47804     { 
47805       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47806       int /* [~128..127] */ i8 = 
47807         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
47808       nextPC = 7 + MATCH_p; 
47809       
47810       #line 1264 "machine/pentium/disassembler.m"
47811       
47812 
47813               sprintf (str,  "ADDiodb", DIS_EADDR32, DIS_I8);
47814 
47815       
47816 
47817       
47818       
47819       
47820     } 
47821     goto MATCH_finished_a; 
47822     
47823   MATCH_label_a719: (void)0; /*placeholder for label*/ 
47824     { 
47825       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47826       int /* [~128..127] */ i8 = 
47827         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
47828       nextPC = 3 + MATCH_p; 
47829       
47830       #line 1258 "machine/pentium/disassembler.m"
47831       
47832 
47833               sprintf (str,  "ORiodb", DIS_EADDR8, DIS_I8);
47834 
47835       
47836 
47837       
47838       
47839       
47840     } 
47841     goto MATCH_finished_a; 
47842     
47843   MATCH_label_a720: (void)0; /*placeholder for label*/ 
47844     { 
47845       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47846       int /* [~128..127] */ i8 = 
47847         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
47848       nextPC = 4 + MATCH_p; 
47849       
47850       #line 1258 "machine/pentium/disassembler.m"
47851       
47852 
47853               sprintf (str,  "ORiodb", DIS_EADDR8, DIS_I8);
47854 
47855       
47856 
47857       
47858       
47859       
47860     } 
47861     goto MATCH_finished_a; 
47862     
47863   MATCH_label_a721: (void)0; /*placeholder for label*/ 
47864     { 
47865       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47866       int /* [~128..127] */ i8 = 
47867         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
47868       nextPC = 8 + MATCH_p; 
47869       
47870       #line 1258 "machine/pentium/disassembler.m"
47871       
47872 
47873               sprintf (str,  "ORiodb", DIS_EADDR8, DIS_I8);
47874 
47875       
47876 
47877       
47878       
47879       
47880     } 
47881     goto MATCH_finished_a; 
47882     
47883   MATCH_label_a722: (void)0; /*placeholder for label*/ 
47884     { 
47885       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47886       int /* [~128..127] */ i8 = 
47887         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
47888       nextPC = 7 + MATCH_p; 
47889       
47890       #line 1258 "machine/pentium/disassembler.m"
47891       
47892 
47893               sprintf (str,  "ORiodb", DIS_EADDR8, DIS_I8);
47894 
47895       
47896 
47897       
47898       
47899       
47900     } 
47901     goto MATCH_finished_a; 
47902     
47903   MATCH_label_a723: (void)0; /*placeholder for label*/ 
47904     { 
47905       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47906       int /* [~128..127] */ i8 = 
47907         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
47908       nextPC = 3 + MATCH_p; 
47909       
47910       #line 1252 "machine/pentium/disassembler.m"
47911       
47912 
47913               sprintf (str,  "ADCiodb", DIS_EADDR8, DIS_I8);
47914 
47915       
47916 
47917       
47918       
47919       
47920     } 
47921     goto MATCH_finished_a; 
47922     
47923   MATCH_label_a724: (void)0; /*placeholder for label*/ 
47924     { 
47925       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47926       int /* [~128..127] */ i8 = 
47927         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
47928       nextPC = 4 + MATCH_p; 
47929       
47930       #line 1252 "machine/pentium/disassembler.m"
47931       
47932 
47933               sprintf (str,  "ADCiodb", DIS_EADDR8, DIS_I8);
47934 
47935       
47936 
47937       
47938       
47939       
47940     } 
47941     goto MATCH_finished_a; 
47942     
47943   MATCH_label_a725: (void)0; /*placeholder for label*/ 
47944     { 
47945       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47946       int /* [~128..127] */ i8 = 
47947         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
47948       nextPC = 8 + MATCH_p; 
47949       
47950       #line 1252 "machine/pentium/disassembler.m"
47951       
47952 
47953               sprintf (str,  "ADCiodb", DIS_EADDR8, DIS_I8);
47954 
47955       
47956 
47957       
47958       
47959       
47960     } 
47961     goto MATCH_finished_a; 
47962     
47963   MATCH_label_a726: (void)0; /*placeholder for label*/ 
47964     { 
47965       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47966       int /* [~128..127] */ i8 = 
47967         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
47968       nextPC = 7 + MATCH_p; 
47969       
47970       #line 1252 "machine/pentium/disassembler.m"
47971       
47972 
47973               sprintf (str,  "ADCiodb", DIS_EADDR8, DIS_I8);
47974 
47975       
47976 
47977       
47978       
47979       
47980     } 
47981     goto MATCH_finished_a; 
47982     
47983   MATCH_label_a727: (void)0; /*placeholder for label*/ 
47984     { 
47985       unsigned Eaddr = 1 + addressToPC(MATCH_p);
47986       int /* [~128..127] */ i8 = 
47987         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
47988       nextPC = 3 + MATCH_p; 
47989       
47990       #line 1246 "machine/pentium/disassembler.m"
47991       
47992 
47993               sprintf (str,  "SBBiodb", DIS_EADDR32, DIS_I8);
47994 
47995       
47996 
47997       
47998       
47999       
48000     } 
48001     goto MATCH_finished_a; 
48002     
48003   MATCH_label_a728: (void)0; /*placeholder for label*/ 
48004     { 
48005       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48006       int /* [~128..127] */ i8 = 
48007         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
48008       nextPC = 4 + MATCH_p; 
48009       
48010       #line 1246 "machine/pentium/disassembler.m"
48011       
48012 
48013               sprintf (str,  "SBBiodb", DIS_EADDR32, DIS_I8);
48014 
48015       
48016 
48017       
48018       
48019       
48020     } 
48021     goto MATCH_finished_a; 
48022     
48023   MATCH_label_a729: (void)0; /*placeholder for label*/ 
48024     { 
48025       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48026       int /* [~128..127] */ i8 = 
48027         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
48028       nextPC = 8 + MATCH_p; 
48029       
48030       #line 1246 "machine/pentium/disassembler.m"
48031       
48032 
48033               sprintf (str,  "SBBiodb", DIS_EADDR32, DIS_I8);
48034 
48035       
48036 
48037       
48038       
48039       
48040     } 
48041     goto MATCH_finished_a; 
48042     
48043   MATCH_label_a730: (void)0; /*placeholder for label*/ 
48044     { 
48045       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48046       int /* [~128..127] */ i8 = 
48047         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
48048       nextPC = 7 + MATCH_p; 
48049       
48050       #line 1246 "machine/pentium/disassembler.m"
48051       
48052 
48053               sprintf (str,  "SBBiodb", DIS_EADDR32, DIS_I8);
48054 
48055       
48056 
48057       
48058       
48059       
48060     } 
48061     goto MATCH_finished_a; 
48062     
48063   MATCH_label_a731: (void)0; /*placeholder for label*/ 
48064     { 
48065       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48066       int /* [~128..127] */ i8 = 
48067         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
48068       nextPC = 3 + MATCH_p; 
48069       
48070       #line 1240 "machine/pentium/disassembler.m"
48071       
48072 
48073               sprintf (str,  "ANDiodb", DIS_EADDR8, DIS_I8);
48074 
48075       
48076 
48077       
48078       
48079       
48080     } 
48081     goto MATCH_finished_a; 
48082     
48083   MATCH_label_a732: (void)0; /*placeholder for label*/ 
48084     { 
48085       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48086       int /* [~128..127] */ i8 = 
48087         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
48088       nextPC = 4 + MATCH_p; 
48089       
48090       #line 1240 "machine/pentium/disassembler.m"
48091       
48092 
48093               sprintf (str,  "ANDiodb", DIS_EADDR8, DIS_I8);
48094 
48095       
48096 
48097       
48098       
48099       
48100     } 
48101     goto MATCH_finished_a; 
48102     
48103   MATCH_label_a733: (void)0; /*placeholder for label*/ 
48104     { 
48105       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48106       int /* [~128..127] */ i8 = 
48107         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
48108       nextPC = 8 + MATCH_p; 
48109       
48110       #line 1240 "machine/pentium/disassembler.m"
48111       
48112 
48113               sprintf (str,  "ANDiodb", DIS_EADDR8, DIS_I8);
48114 
48115       
48116 
48117       
48118       
48119       
48120     } 
48121     goto MATCH_finished_a; 
48122     
48123   MATCH_label_a734: (void)0; /*placeholder for label*/ 
48124     { 
48125       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48126       int /* [~128..127] */ i8 = 
48127         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
48128       nextPC = 7 + MATCH_p; 
48129       
48130       #line 1240 "machine/pentium/disassembler.m"
48131       
48132 
48133               sprintf (str,  "ANDiodb", DIS_EADDR8, DIS_I8);
48134 
48135       
48136 
48137       
48138       
48139       
48140     } 
48141     goto MATCH_finished_a; 
48142     
48143   MATCH_label_a735: (void)0; /*placeholder for label*/ 
48144     { 
48145       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48146       int /* [~128..127] */ i8 = 
48147         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
48148       nextPC = 3 + MATCH_p; 
48149       
48150       #line 1234 "machine/pentium/disassembler.m"
48151       
48152 
48153               sprintf (str,  "SUBiodb", DIS_EADDR32, DIS_I8);
48154 
48155       
48156 
48157       
48158       
48159       
48160     } 
48161     goto MATCH_finished_a; 
48162     
48163   MATCH_label_a736: (void)0; /*placeholder for label*/ 
48164     { 
48165       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48166       int /* [~128..127] */ i8 = 
48167         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
48168       nextPC = 4 + MATCH_p; 
48169       
48170       #line 1234 "machine/pentium/disassembler.m"
48171       
48172 
48173               sprintf (str,  "SUBiodb", DIS_EADDR32, DIS_I8);
48174 
48175       
48176 
48177       
48178       
48179       
48180     } 
48181     goto MATCH_finished_a; 
48182     
48183   MATCH_label_a737: (void)0; /*placeholder for label*/ 
48184     { 
48185       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48186       int /* [~128..127] */ i8 = 
48187         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
48188       nextPC = 8 + MATCH_p; 
48189       
48190       #line 1234 "machine/pentium/disassembler.m"
48191       
48192 
48193               sprintf (str,  "SUBiodb", DIS_EADDR32, DIS_I8);
48194 
48195       
48196 
48197       
48198       
48199       
48200     } 
48201     goto MATCH_finished_a; 
48202     
48203   MATCH_label_a738: (void)0; /*placeholder for label*/ 
48204     { 
48205       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48206       int /* [~128..127] */ i8 = 
48207         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
48208       nextPC = 7 + MATCH_p; 
48209       
48210       #line 1234 "machine/pentium/disassembler.m"
48211       
48212 
48213               sprintf (str,  "SUBiodb", DIS_EADDR32, DIS_I8);
48214 
48215       
48216 
48217       
48218       
48219       
48220     } 
48221     goto MATCH_finished_a; 
48222     
48223   MATCH_label_a739: (void)0; /*placeholder for label*/ 
48224     { 
48225       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48226       int /* [~128..127] */ i8 = 
48227         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
48228       nextPC = 3 + MATCH_p; 
48229       
48230       #line 1228 "machine/pentium/disassembler.m"
48231       
48232 
48233               sprintf (str,  "XORiodb", DIS_EADDR8, DIS_I8);
48234 
48235       
48236 
48237       
48238       
48239       
48240     } 
48241     goto MATCH_finished_a; 
48242     
48243   MATCH_label_a740: (void)0; /*placeholder for label*/ 
48244     { 
48245       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48246       int /* [~128..127] */ i8 = 
48247         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
48248       nextPC = 4 + MATCH_p; 
48249       
48250       #line 1228 "machine/pentium/disassembler.m"
48251       
48252 
48253               sprintf (str,  "XORiodb", DIS_EADDR8, DIS_I8);
48254 
48255       
48256 
48257       
48258       
48259       
48260     } 
48261     goto MATCH_finished_a; 
48262     
48263   MATCH_label_a741: (void)0; /*placeholder for label*/ 
48264     { 
48265       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48266       int /* [~128..127] */ i8 = 
48267         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
48268       nextPC = 8 + MATCH_p; 
48269       
48270       #line 1228 "machine/pentium/disassembler.m"
48271       
48272 
48273               sprintf (str,  "XORiodb", DIS_EADDR8, DIS_I8);
48274 
48275       
48276 
48277       
48278       
48279       
48280     } 
48281     goto MATCH_finished_a; 
48282     
48283   MATCH_label_a742: (void)0; /*placeholder for label*/ 
48284     { 
48285       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48286       int /* [~128..127] */ i8 = 
48287         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
48288       nextPC = 7 + MATCH_p; 
48289       
48290       #line 1228 "machine/pentium/disassembler.m"
48291       
48292 
48293               sprintf (str,  "XORiodb", DIS_EADDR8, DIS_I8);
48294 
48295       
48296 
48297       
48298       
48299       
48300     } 
48301     goto MATCH_finished_a; 
48302     
48303   MATCH_label_a743: (void)0; /*placeholder for label*/ 
48304     { 
48305       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48306       int /* [~128..127] */ i8 = 
48307         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
48308       nextPC = 3 + MATCH_p; 
48309       
48310       #line 1222 "machine/pentium/disassembler.m"
48311       
48312 
48313               sprintf (str,  "CMPiodb", DIS_EADDR32, DIS_I8);
48314 
48315       
48316 
48317       
48318       
48319       
48320     } 
48321     goto MATCH_finished_a; 
48322     
48323   MATCH_label_a744: (void)0; /*placeholder for label*/ 
48324     { 
48325       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48326       int /* [~128..127] */ i8 = 
48327         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
48328       nextPC = 4 + MATCH_p; 
48329       
48330       #line 1222 "machine/pentium/disassembler.m"
48331       
48332 
48333               sprintf (str,  "CMPiodb", DIS_EADDR32, DIS_I8);
48334 
48335       
48336 
48337       
48338       
48339       
48340     } 
48341     goto MATCH_finished_a; 
48342     
48343   MATCH_label_a745: (void)0; /*placeholder for label*/ 
48344     { 
48345       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48346       int /* [~128..127] */ i8 = 
48347         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
48348       nextPC = 8 + MATCH_p; 
48349       
48350       #line 1222 "machine/pentium/disassembler.m"
48351       
48352 
48353               sprintf (str,  "CMPiodb", DIS_EADDR32, DIS_I8);
48354 
48355       
48356 
48357       
48358       
48359       
48360     } 
48361     goto MATCH_finished_a; 
48362     
48363   MATCH_label_a746: (void)0; /*placeholder for label*/ 
48364     { 
48365       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48366       int /* [~128..127] */ i8 = 
48367         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
48368       nextPC = 7 + MATCH_p; 
48369       
48370       #line 1222 "machine/pentium/disassembler.m"
48371       
48372 
48373               sprintf (str,  "CMPiodb", DIS_EADDR32, DIS_I8);
48374 
48375       
48376 
48377       
48378       
48379       
48380     } 
48381     goto MATCH_finished_a; 
48382     
48383   MATCH_label_a747: (void)0; /*placeholder for label*/ 
48384     { 
48385       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48386       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48387       nextPC = 2 + MATCH_p; 
48388       
48389       #line 101 "machine/pentium/disassembler.m"
48390       
48391 
48392               sprintf (str,  "TEST.Eb.Gb", DIS_EADDR8, DIS_REG8);
48393 
48394       
48395 
48396       
48397       
48398       
48399     } 
48400     goto MATCH_finished_a; 
48401     
48402   MATCH_label_a748: (void)0; /*placeholder for label*/ 
48403     { 
48404       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48405       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48406       nextPC = 3 + MATCH_p; 
48407       
48408       #line 101 "machine/pentium/disassembler.m"
48409       
48410 
48411               sprintf (str,  "TEST.Eb.Gb", DIS_EADDR8, DIS_REG8);
48412 
48413       
48414 
48415       
48416       
48417       
48418     } 
48419     goto MATCH_finished_a; 
48420     
48421   MATCH_label_a749: (void)0; /*placeholder for label*/ 
48422     { 
48423       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48424       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48425       nextPC = 7 + MATCH_p; 
48426       
48427       #line 101 "machine/pentium/disassembler.m"
48428       
48429 
48430               sprintf (str,  "TEST.Eb.Gb", DIS_EADDR8, DIS_REG8);
48431 
48432       
48433 
48434       
48435       
48436       
48437     } 
48438     goto MATCH_finished_a; 
48439     
48440   MATCH_label_a750: (void)0; /*placeholder for label*/ 
48441     { 
48442       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48443       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48444       nextPC = 6 + MATCH_p; 
48445       
48446       #line 101 "machine/pentium/disassembler.m"
48447       
48448 
48449               sprintf (str,  "TEST.Eb.Gb", DIS_EADDR8, DIS_REG8);
48450 
48451       
48452 
48453       
48454       
48455       
48456     } 
48457     goto MATCH_finished_a; 
48458     
48459   MATCH_label_a751: (void)0; /*placeholder for label*/ 
48460     { 
48461       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48462       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48463       nextPC = 2 + MATCH_p; 
48464       
48465       #line 95 "machine/pentium/disassembler.m"
48466       
48467 
48468               sprintf (str,  "TEST.Ev.Gvod", DIS_EADDR32, DIS_REG32);
48469 
48470       
48471 
48472       
48473       
48474       
48475     } 
48476     goto MATCH_finished_a; 
48477     
48478   MATCH_label_a752: (void)0; /*placeholder for label*/ 
48479     { 
48480       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48481       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48482       nextPC = 3 + MATCH_p; 
48483       
48484       #line 95 "machine/pentium/disassembler.m"
48485       
48486 
48487               sprintf (str,  "TEST.Ev.Gvod", DIS_EADDR32, DIS_REG32);
48488 
48489       
48490 
48491       
48492       
48493       
48494     } 
48495     goto MATCH_finished_a; 
48496     
48497   MATCH_label_a753: (void)0; /*placeholder for label*/ 
48498     { 
48499       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48500       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48501       nextPC = 7 + MATCH_p; 
48502       
48503       #line 95 "machine/pentium/disassembler.m"
48504       
48505 
48506               sprintf (str,  "TEST.Ev.Gvod", DIS_EADDR32, DIS_REG32);
48507 
48508       
48509 
48510       
48511       
48512       
48513     } 
48514     goto MATCH_finished_a; 
48515     
48516   MATCH_label_a754: (void)0; /*placeholder for label*/ 
48517     { 
48518       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48519       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48520       nextPC = 6 + MATCH_p; 
48521       
48522       #line 95 "machine/pentium/disassembler.m"
48523       
48524 
48525               sprintf (str,  "TEST.Ev.Gvod", DIS_EADDR32, DIS_REG32);
48526 
48527       
48528 
48529       
48530       
48531       
48532     } 
48533     goto MATCH_finished_a; 
48534     
48535   MATCH_label_a755: (void)0; /*placeholder for label*/ 
48536     { 
48537       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48538       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48539       nextPC = 2 + MATCH_p; 
48540       
48541       #line 53 "machine/pentium/disassembler.m"
48542       
48543 
48544               sprintf (str, "%s %s,%s", "XCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
48545 
48546       
48547 
48548       
48549       
48550       
48551     } 
48552     goto MATCH_finished_a; 
48553     
48554   MATCH_label_a756: (void)0; /*placeholder for label*/ 
48555     { 
48556       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48557       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48558       nextPC = 3 + MATCH_p; 
48559       
48560       #line 53 "machine/pentium/disassembler.m"
48561       
48562 
48563               sprintf (str, "%s %s,%s", "XCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
48564 
48565       
48566 
48567       
48568       
48569       
48570     } 
48571     goto MATCH_finished_a; 
48572     
48573   MATCH_label_a757: (void)0; /*placeholder for label*/ 
48574     { 
48575       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48576       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48577       nextPC = 7 + MATCH_p; 
48578       
48579       #line 53 "machine/pentium/disassembler.m"
48580       
48581 
48582               sprintf (str, "%s %s,%s", "XCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
48583 
48584       
48585 
48586       
48587       
48588       
48589     } 
48590     goto MATCH_finished_a; 
48591     
48592   MATCH_label_a758: (void)0; /*placeholder for label*/ 
48593     { 
48594       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48595       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48596       nextPC = 6 + MATCH_p; 
48597       
48598       #line 53 "machine/pentium/disassembler.m"
48599       
48600 
48601               sprintf (str, "%s %s,%s", "XCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
48602 
48603       
48604 
48605       
48606       
48607       
48608     } 
48609     goto MATCH_finished_a; 
48610     
48611   MATCH_label_a759: (void)0; /*placeholder for label*/ 
48612     { 
48613       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48614       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48615       nextPC = 2 + MATCH_p; 
48616       
48617       #line 47 "machine/pentium/disassembler.m"
48618       
48619 
48620               sprintf (str, "%s %s,%s", "XCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
48621 
48622       
48623 
48624       
48625       
48626       
48627     } 
48628     goto MATCH_finished_a; 
48629     
48630   MATCH_label_a760: (void)0; /*placeholder for label*/ 
48631     { 
48632       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48633       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48634       nextPC = 3 + MATCH_p; 
48635       
48636       #line 47 "machine/pentium/disassembler.m"
48637       
48638 
48639               sprintf (str, "%s %s,%s", "XCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
48640 
48641       
48642 
48643       
48644       
48645       
48646     } 
48647     goto MATCH_finished_a; 
48648     
48649   MATCH_label_a761: (void)0; /*placeholder for label*/ 
48650     { 
48651       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48652       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48653       nextPC = 7 + MATCH_p; 
48654       
48655       #line 47 "machine/pentium/disassembler.m"
48656       
48657 
48658               sprintf (str, "%s %s,%s", "XCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
48659 
48660       
48661 
48662       
48663       
48664       
48665     } 
48666     goto MATCH_finished_a; 
48667     
48668   MATCH_label_a762: (void)0; /*placeholder for label*/ 
48669     { 
48670       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48671       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48672       nextPC = 6 + MATCH_p; 
48673       
48674       #line 47 "machine/pentium/disassembler.m"
48675       
48676 
48677               sprintf (str, "%s %s,%s", "XCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
48678 
48679       
48680 
48681       
48682       
48683       
48684     } 
48685     goto MATCH_finished_a; 
48686     
48687   MATCH_label_a763: (void)0; /*placeholder for label*/ 
48688     { 
48689       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48690       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48691       nextPC = 2 + MATCH_p; 
48692       
48693       #line 742 "machine/pentium/disassembler.m"
48694       
48695 
48696               sprintf (str,  "MOVmrb", DIS_EADDR8, DIS_REG8);
48697 
48698       
48699 
48700       
48701       
48702       
48703     } 
48704     goto MATCH_finished_a; 
48705     
48706   MATCH_label_a764: (void)0; /*placeholder for label*/ 
48707     { 
48708       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48709       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48710       nextPC = 3 + MATCH_p; 
48711       
48712       #line 742 "machine/pentium/disassembler.m"
48713       
48714 
48715               sprintf (str,  "MOVmrb", DIS_EADDR8, DIS_REG8);
48716 
48717       
48718 
48719       
48720       
48721       
48722     } 
48723     goto MATCH_finished_a; 
48724     
48725   MATCH_label_a765: (void)0; /*placeholder for label*/ 
48726     { 
48727       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48728       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48729       nextPC = 7 + MATCH_p; 
48730       
48731       #line 742 "machine/pentium/disassembler.m"
48732       
48733 
48734               sprintf (str,  "MOVmrb", DIS_EADDR8, DIS_REG8);
48735 
48736       
48737 
48738       
48739       
48740       
48741     } 
48742     goto MATCH_finished_a; 
48743     
48744   MATCH_label_a766: (void)0; /*placeholder for label*/ 
48745     { 
48746       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48747       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48748       nextPC = 6 + MATCH_p; 
48749       
48750       #line 742 "machine/pentium/disassembler.m"
48751       
48752 
48753               sprintf (str,  "MOVmrb", DIS_EADDR8, DIS_REG8);
48754 
48755       
48756 
48757       
48758       
48759       
48760     } 
48761     goto MATCH_finished_a; 
48762     
48763   MATCH_label_a767: (void)0; /*placeholder for label*/ 
48764     { 
48765       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48766       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48767       nextPC = 2 + MATCH_p; 
48768       
48769       #line 736 "machine/pentium/disassembler.m"
48770       
48771 
48772               sprintf (str,  "MOVmrod", DIS_EADDR32, DIS_REG32);
48773 
48774       
48775 
48776       
48777       
48778       
48779     } 
48780     goto MATCH_finished_a; 
48781     
48782   MATCH_label_a768: (void)0; /*placeholder for label*/ 
48783     { 
48784       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48785       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48786       nextPC = 3 + MATCH_p; 
48787       
48788       #line 736 "machine/pentium/disassembler.m"
48789       
48790 
48791               sprintf (str,  "MOVmrod", DIS_EADDR32, DIS_REG32);
48792 
48793       
48794 
48795       
48796       
48797       
48798     } 
48799     goto MATCH_finished_a; 
48800     
48801   MATCH_label_a769: (void)0; /*placeholder for label*/ 
48802     { 
48803       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48804       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48805       nextPC = 7 + MATCH_p; 
48806       
48807       #line 736 "machine/pentium/disassembler.m"
48808       
48809 
48810               sprintf (str,  "MOVmrod", DIS_EADDR32, DIS_REG32);
48811 
48812       
48813 
48814       
48815       
48816       
48817     } 
48818     goto MATCH_finished_a; 
48819     
48820   MATCH_label_a770: (void)0; /*placeholder for label*/ 
48821     { 
48822       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48823       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48824       nextPC = 6 + MATCH_p; 
48825       
48826       #line 736 "machine/pentium/disassembler.m"
48827       
48828 
48829               sprintf (str,  "MOVmrod", DIS_EADDR32, DIS_REG32);
48830 
48831       
48832 
48833       
48834       
48835       
48836     } 
48837     goto MATCH_finished_a; 
48838     
48839   MATCH_label_a771: (void)0; /*placeholder for label*/ 
48840     { 
48841       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48842       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48843       nextPC = 2 + MATCH_p; 
48844       
48845       #line 733 "machine/pentium/disassembler.m"
48846       
48847 
48848               sprintf (str,  "MOVrmb", DIS_REG8, DIS_EADDR8);
48849 
48850       
48851 
48852       
48853       
48854       
48855     } 
48856     goto MATCH_finished_a; 
48857     
48858   MATCH_label_a772: (void)0; /*placeholder for label*/ 
48859     { 
48860       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48861       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48862       nextPC = 3 + MATCH_p; 
48863       
48864       #line 733 "machine/pentium/disassembler.m"
48865       
48866 
48867               sprintf (str,  "MOVrmb", DIS_REG8, DIS_EADDR8);
48868 
48869       
48870 
48871       
48872       
48873       
48874     } 
48875     goto MATCH_finished_a; 
48876     
48877   MATCH_label_a773: (void)0; /*placeholder for label*/ 
48878     { 
48879       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48880       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48881       nextPC = 7 + MATCH_p; 
48882       
48883       #line 733 "machine/pentium/disassembler.m"
48884       
48885 
48886               sprintf (str,  "MOVrmb", DIS_REG8, DIS_EADDR8);
48887 
48888       
48889 
48890       
48891       
48892       
48893     } 
48894     goto MATCH_finished_a; 
48895     
48896   MATCH_label_a774: (void)0; /*placeholder for label*/ 
48897     { 
48898       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48899       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48900       nextPC = 6 + MATCH_p; 
48901       
48902       #line 733 "machine/pentium/disassembler.m"
48903       
48904 
48905               sprintf (str,  "MOVrmb", DIS_REG8, DIS_EADDR8);
48906 
48907       
48908 
48909       
48910       
48911       
48912     } 
48913     goto MATCH_finished_a; 
48914     
48915   MATCH_label_a775: (void)0; /*placeholder for label*/ 
48916     { 
48917       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48918       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48919       nextPC = 2 + MATCH_p; 
48920       
48921       #line 727 "machine/pentium/disassembler.m"
48922       
48923 
48924               sprintf (str,  "MOVrmod", DIS_REG32, DIS_EADDR32);
48925 
48926       
48927 
48928       
48929       
48930       
48931     } 
48932     goto MATCH_finished_a; 
48933     
48934   MATCH_label_a776: (void)0; /*placeholder for label*/ 
48935     { 
48936       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48937       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48938       nextPC = 3 + MATCH_p; 
48939       
48940       #line 727 "machine/pentium/disassembler.m"
48941       
48942 
48943               sprintf (str,  "MOVrmod", DIS_REG32, DIS_EADDR32);
48944 
48945       
48946 
48947       
48948       
48949       
48950     } 
48951     goto MATCH_finished_a; 
48952     
48953   MATCH_label_a777: (void)0; /*placeholder for label*/ 
48954     { 
48955       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48956       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48957       nextPC = 7 + MATCH_p; 
48958       
48959       #line 727 "machine/pentium/disassembler.m"
48960       
48961 
48962               sprintf (str,  "MOVrmod", DIS_REG32, DIS_EADDR32);
48963 
48964       
48965 
48966       
48967       
48968       
48969     } 
48970     goto MATCH_finished_a; 
48971     
48972   MATCH_label_a778: (void)0; /*placeholder for label*/ 
48973     { 
48974       unsigned Eaddr = 1 + addressToPC(MATCH_p);
48975       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48976       nextPC = 6 + MATCH_p; 
48977       
48978       #line 727 "machine/pentium/disassembler.m"
48979       
48980 
48981               sprintf (str,  "MOVrmod", DIS_REG32, DIS_EADDR32);
48982 
48983       
48984 
48985       
48986       
48987       
48988     } 
48989     goto MATCH_finished_a; 
48990     
48991   MATCH_label_a779: (void)0; /*placeholder for label*/ 
48992     { 
48993       unsigned Mem = 1 + addressToPC(MATCH_p);
48994       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
48995       nextPC = 3 + MATCH_p; 
48996       
48997       #line 778 "machine/pentium/disassembler.m"
48998       
48999 
49000               sprintf (str,  "LEA.od", DIS_REG32, DIS_MEM);
49001 
49002       
49003 
49004       
49005       
49006       
49007     } 
49008     goto MATCH_finished_a; 
49009     
49010   MATCH_label_a780: (void)0; /*placeholder for label*/ 
49011     { 
49012       unsigned Mem = 1 + addressToPC(MATCH_p);
49013       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
49014       nextPC = 7 + MATCH_p; 
49015       
49016       #line 778 "machine/pentium/disassembler.m"
49017       
49018 
49019               sprintf (str,  "LEA.od", DIS_REG32, DIS_MEM);
49020 
49021       
49022 
49023       
49024       
49025       
49026     } 
49027     goto MATCH_finished_a; 
49028     
49029   MATCH_label_a781: (void)0; /*placeholder for label*/ 
49030     { 
49031       unsigned Mem = 1 + addressToPC(MATCH_p);
49032       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
49033       nextPC = 6 + MATCH_p; 
49034       
49035       #line 778 "machine/pentium/disassembler.m"
49036       
49037 
49038               sprintf (str,  "LEA.od", DIS_REG32, DIS_MEM);
49039 
49040       
49041 
49042       
49043       
49044       
49045     } 
49046     goto MATCH_finished_a; 
49047     
49048   MATCH_label_a782: (void)0; /*placeholder for label*/ 
49049     { 
49050       unsigned Mem = 1 + addressToPC(MATCH_p);
49051       nextPC = 3 + MATCH_p; 
49052       
49053       #line 582 "machine/pentium/disassembler.m"
49054       
49055 
49056               sprintf (str,  "POP.Evod", DIS_MEM);
49057 
49058       
49059 
49060       
49061       
49062       
49063     } 
49064     goto MATCH_finished_a; 
49065     
49066   MATCH_label_a783: (void)0; /*placeholder for label*/ 
49067     { 
49068       unsigned Mem = 1 + addressToPC(MATCH_p);
49069       nextPC = 7 + MATCH_p; 
49070       
49071       #line 582 "machine/pentium/disassembler.m"
49072       
49073 
49074               sprintf (str,  "POP.Evod", DIS_MEM);
49075 
49076       
49077 
49078       
49079       
49080       
49081     } 
49082     goto MATCH_finished_a; 
49083     
49084   MATCH_label_a784: (void)0; /*placeholder for label*/ 
49085     { 
49086       unsigned Mem = 1 + addressToPC(MATCH_p);
49087       nextPC = 6 + MATCH_p; 
49088       
49089       #line 582 "machine/pentium/disassembler.m"
49090       
49091 
49092               sprintf (str,  "POP.Evod", DIS_MEM);
49093 
49094       
49095 
49096       
49097       
49098       
49099     } 
49100     goto MATCH_finished_a; 
49101     
49102   MATCH_label_a785: (void)0; /*placeholder for label*/ 
49103     { 
49104       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49105       int /* [~128..127] */ i8 = 
49106         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
49107       nextPC = 3 + MATCH_p; 
49108       
49109       #line 366 "machine/pentium/disassembler.m"
49110       
49111 
49112               sprintf (str,  "ROLB.Eb.Ib", DIS_EADDR8, DIS_I8);
49113 
49114       
49115 
49116       
49117       
49118       
49119     } 
49120     goto MATCH_finished_a; 
49121     
49122   MATCH_label_a786: (void)0; /*placeholder for label*/ 
49123     { 
49124       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49125       int /* [~128..127] */ i8 = 
49126         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
49127       nextPC = 4 + MATCH_p; 
49128       
49129       #line 366 "machine/pentium/disassembler.m"
49130       
49131 
49132               sprintf (str,  "ROLB.Eb.Ib", DIS_EADDR8, DIS_I8);
49133 
49134       
49135 
49136       
49137       
49138       
49139     } 
49140     goto MATCH_finished_a; 
49141     
49142   MATCH_label_a787: (void)0; /*placeholder for label*/ 
49143     { 
49144       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49145       int /* [~128..127] */ i8 = 
49146         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
49147       nextPC = 8 + MATCH_p; 
49148       
49149       #line 366 "machine/pentium/disassembler.m"
49150       
49151 
49152               sprintf (str,  "ROLB.Eb.Ib", DIS_EADDR8, DIS_I8);
49153 
49154       
49155 
49156       
49157       
49158       
49159     } 
49160     goto MATCH_finished_a; 
49161     
49162   MATCH_label_a788: (void)0; /*placeholder for label*/ 
49163     { 
49164       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49165       int /* [~128..127] */ i8 = 
49166         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
49167       nextPC = 7 + MATCH_p; 
49168       
49169       #line 366 "machine/pentium/disassembler.m"
49170       
49171 
49172               sprintf (str,  "ROLB.Eb.Ib", DIS_EADDR8, DIS_I8);
49173 
49174       
49175 
49176       
49177       
49178       
49179     } 
49180     goto MATCH_finished_a; 
49181     
49182   MATCH_label_a789: (void)0; /*placeholder for label*/ 
49183     { 
49184       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49185       int /* [~128..127] */ i8 = 
49186         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
49187       nextPC = 3 + MATCH_p; 
49188       
49189       #line 363 "machine/pentium/disassembler.m"
49190       
49191 
49192               sprintf (str,  "RORB.Eb.Ib", DIS_EADDR8, DIS_I8);
49193 
49194       
49195 
49196       
49197       
49198       
49199     } 
49200     goto MATCH_finished_a; 
49201     
49202   MATCH_label_a790: (void)0; /*placeholder for label*/ 
49203     { 
49204       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49205       int /* [~128..127] */ i8 = 
49206         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
49207       nextPC = 4 + MATCH_p; 
49208       
49209       #line 363 "machine/pentium/disassembler.m"
49210       
49211 
49212               sprintf (str,  "RORB.Eb.Ib", DIS_EADDR8, DIS_I8);
49213 
49214       
49215 
49216       
49217       
49218       
49219     } 
49220     goto MATCH_finished_a; 
49221     
49222   MATCH_label_a791: (void)0; /*placeholder for label*/ 
49223     { 
49224       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49225       int /* [~128..127] */ i8 = 
49226         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
49227       nextPC = 8 + MATCH_p; 
49228       
49229       #line 363 "machine/pentium/disassembler.m"
49230       
49231 
49232               sprintf (str,  "RORB.Eb.Ib", DIS_EADDR8, DIS_I8);
49233 
49234       
49235 
49236       
49237       
49238       
49239     } 
49240     goto MATCH_finished_a; 
49241     
49242   MATCH_label_a792: (void)0; /*placeholder for label*/ 
49243     { 
49244       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49245       int /* [~128..127] */ i8 = 
49246         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
49247       nextPC = 7 + MATCH_p; 
49248       
49249       #line 363 "machine/pentium/disassembler.m"
49250       
49251 
49252               sprintf (str,  "RORB.Eb.Ib", DIS_EADDR8, DIS_I8);
49253 
49254       
49255 
49256       
49257       
49258       
49259     } 
49260     goto MATCH_finished_a; 
49261     
49262   MATCH_label_a793: (void)0; /*placeholder for label*/ 
49263     { 
49264       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49265       int /* [~128..127] */ i8 = 
49266         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
49267       nextPC = 3 + MATCH_p; 
49268       
49269       #line 360 "machine/pentium/disassembler.m"
49270       
49271 
49272               sprintf (str,  "RCLB.Eb.Ib", DIS_EADDR8, DIS_I8);
49273 
49274       
49275 
49276       
49277       
49278       
49279     } 
49280     goto MATCH_finished_a; 
49281     
49282   MATCH_label_a794: (void)0; /*placeholder for label*/ 
49283     { 
49284       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49285       int /* [~128..127] */ i8 = 
49286         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
49287       nextPC = 4 + MATCH_p; 
49288       
49289       #line 360 "machine/pentium/disassembler.m"
49290       
49291 
49292               sprintf (str,  "RCLB.Eb.Ib", DIS_EADDR8, DIS_I8);
49293 
49294       
49295 
49296       
49297       
49298       
49299     } 
49300     goto MATCH_finished_a; 
49301     
49302   MATCH_label_a795: (void)0; /*placeholder for label*/ 
49303     { 
49304       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49305       int /* [~128..127] */ i8 = 
49306         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
49307       nextPC = 8 + MATCH_p; 
49308       
49309       #line 360 "machine/pentium/disassembler.m"
49310       
49311 
49312               sprintf (str,  "RCLB.Eb.Ib", DIS_EADDR8, DIS_I8);
49313 
49314       
49315 
49316       
49317       
49318       
49319     } 
49320     goto MATCH_finished_a; 
49321     
49322   MATCH_label_a796: (void)0; /*placeholder for label*/ 
49323     { 
49324       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49325       int /* [~128..127] */ i8 = 
49326         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
49327       nextPC = 7 + MATCH_p; 
49328       
49329       #line 360 "machine/pentium/disassembler.m"
49330       
49331 
49332               sprintf (str,  "RCLB.Eb.Ib", DIS_EADDR8, DIS_I8);
49333 
49334       
49335 
49336       
49337       
49338       
49339     } 
49340     goto MATCH_finished_a; 
49341     
49342   MATCH_label_a797: (void)0; /*placeholder for label*/ 
49343     { 
49344       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49345       int /* [~128..127] */ i8 = 
49346         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
49347       nextPC = 3 + MATCH_p; 
49348       
49349       #line 357 "machine/pentium/disassembler.m"
49350       
49351 
49352               sprintf (str,  "RCRB.Eb.Ib", DIS_EADDR8, DIS_I8);
49353 
49354       
49355 
49356       
49357       
49358       
49359     } 
49360     goto MATCH_finished_a; 
49361     
49362   MATCH_label_a798: (void)0; /*placeholder for label*/ 
49363     { 
49364       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49365       int /* [~128..127] */ i8 = 
49366         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
49367       nextPC = 4 + MATCH_p; 
49368       
49369       #line 357 "machine/pentium/disassembler.m"
49370       
49371 
49372               sprintf (str,  "RCRB.Eb.Ib", DIS_EADDR8, DIS_I8);
49373 
49374       
49375 
49376       
49377       
49378       
49379     } 
49380     goto MATCH_finished_a; 
49381     
49382   MATCH_label_a799: (void)0; /*placeholder for label*/ 
49383     { 
49384       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49385       int /* [~128..127] */ i8 = 
49386         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
49387       nextPC = 8 + MATCH_p; 
49388       
49389       #line 357 "machine/pentium/disassembler.m"
49390       
49391 
49392               sprintf (str,  "RCRB.Eb.Ib", DIS_EADDR8, DIS_I8);
49393 
49394       
49395 
49396       
49397       
49398       
49399     } 
49400     goto MATCH_finished_a; 
49401     
49402   MATCH_label_a800: (void)0; /*placeholder for label*/ 
49403     { 
49404       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49405       int /* [~128..127] */ i8 = 
49406         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
49407       nextPC = 7 + MATCH_p; 
49408       
49409       #line 357 "machine/pentium/disassembler.m"
49410       
49411 
49412               sprintf (str,  "RCRB.Eb.Ib", DIS_EADDR8, DIS_I8);
49413 
49414       
49415 
49416       
49417       
49418       
49419     } 
49420     goto MATCH_finished_a; 
49421     
49422   MATCH_label_a801: (void)0; /*placeholder for label*/ 
49423     { 
49424       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49425       int /* [~128..127] */ i8 = 
49426         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
49427       nextPC = 3 + MATCH_p; 
49428       
49429       #line 354 "machine/pentium/disassembler.m"
49430       
49431 
49432               sprintf (str,  "SHLSALB.Eb.Ib", DIS_EADDR8, DIS_I8);
49433 
49434       
49435 
49436       
49437       
49438       
49439     } 
49440     goto MATCH_finished_a; 
49441     
49442   MATCH_label_a802: (void)0; /*placeholder for label*/ 
49443     { 
49444       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49445       int /* [~128..127] */ i8 = 
49446         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
49447       nextPC = 4 + MATCH_p; 
49448       
49449       #line 354 "machine/pentium/disassembler.m"
49450       
49451 
49452               sprintf (str,  "SHLSALB.Eb.Ib", DIS_EADDR8, DIS_I8);
49453 
49454       
49455 
49456       
49457       
49458       
49459     } 
49460     goto MATCH_finished_a; 
49461     
49462   MATCH_label_a803: (void)0; /*placeholder for label*/ 
49463     { 
49464       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49465       int /* [~128..127] */ i8 = 
49466         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
49467       nextPC = 8 + MATCH_p; 
49468       
49469       #line 354 "machine/pentium/disassembler.m"
49470       
49471 
49472               sprintf (str,  "SHLSALB.Eb.Ib", DIS_EADDR8, DIS_I8);
49473 
49474       
49475 
49476       
49477       
49478       
49479     } 
49480     goto MATCH_finished_a; 
49481     
49482   MATCH_label_a804: (void)0; /*placeholder for label*/ 
49483     { 
49484       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49485       int /* [~128..127] */ i8 = 
49486         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
49487       nextPC = 7 + MATCH_p; 
49488       
49489       #line 354 "machine/pentium/disassembler.m"
49490       
49491 
49492               sprintf (str,  "SHLSALB.Eb.Ib", DIS_EADDR8, DIS_I8);
49493 
49494       
49495 
49496       
49497       
49498       
49499     } 
49500     goto MATCH_finished_a; 
49501     
49502   MATCH_label_a805: (void)0; /*placeholder for label*/ 
49503     { 
49504       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49505       int /* [~128..127] */ i8 = 
49506         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
49507       nextPC = 3 + MATCH_p; 
49508       
49509       #line 351 "machine/pentium/disassembler.m"
49510       
49511 
49512               sprintf (str,  "SHRB.Eb.Ib", DIS_EADDR8, DIS_I8);
49513 
49514       
49515 
49516       
49517       
49518       
49519     } 
49520     goto MATCH_finished_a; 
49521     
49522   MATCH_label_a806: (void)0; /*placeholder for label*/ 
49523     { 
49524       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49525       int /* [~128..127] */ i8 = 
49526         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
49527       nextPC = 4 + MATCH_p; 
49528       
49529       #line 351 "machine/pentium/disassembler.m"
49530       
49531 
49532               sprintf (str,  "SHRB.Eb.Ib", DIS_EADDR8, DIS_I8);
49533 
49534       
49535 
49536       
49537       
49538       
49539     } 
49540     goto MATCH_finished_a; 
49541     
49542   MATCH_label_a807: (void)0; /*placeholder for label*/ 
49543     { 
49544       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49545       int /* [~128..127] */ i8 = 
49546         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
49547       nextPC = 8 + MATCH_p; 
49548       
49549       #line 351 "machine/pentium/disassembler.m"
49550       
49551 
49552               sprintf (str,  "SHRB.Eb.Ib", DIS_EADDR8, DIS_I8);
49553 
49554       
49555 
49556       
49557       
49558       
49559     } 
49560     goto MATCH_finished_a; 
49561     
49562   MATCH_label_a808: (void)0; /*placeholder for label*/ 
49563     { 
49564       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49565       int /* [~128..127] */ i8 = 
49566         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
49567       nextPC = 7 + MATCH_p; 
49568       
49569       #line 351 "machine/pentium/disassembler.m"
49570       
49571 
49572               sprintf (str,  "SHRB.Eb.Ib", DIS_EADDR8, DIS_I8);
49573 
49574       
49575 
49576       
49577       
49578       
49579     } 
49580     goto MATCH_finished_a; 
49581     
49582   MATCH_label_a809: (void)0; /*placeholder for label*/ 
49583     { 
49584       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49585       int /* [~128..127] */ i8 = 
49586         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
49587       nextPC = 3 + MATCH_p; 
49588       
49589       #line 348 "machine/pentium/disassembler.m"
49590       
49591 
49592               sprintf (str,  "SARB.Eb.Ib", DIS_EADDR8, DIS_I8);
49593 
49594       
49595 
49596       
49597       
49598       
49599     } 
49600     goto MATCH_finished_a; 
49601     
49602   MATCH_label_a810: (void)0; /*placeholder for label*/ 
49603     { 
49604       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49605       int /* [~128..127] */ i8 = 
49606         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
49607       nextPC = 4 + MATCH_p; 
49608       
49609       #line 348 "machine/pentium/disassembler.m"
49610       
49611 
49612               sprintf (str,  "SARB.Eb.Ib", DIS_EADDR8, DIS_I8);
49613 
49614       
49615 
49616       
49617       
49618       
49619     } 
49620     goto MATCH_finished_a; 
49621     
49622   MATCH_label_a811: (void)0; /*placeholder for label*/ 
49623     { 
49624       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49625       int /* [~128..127] */ i8 = 
49626         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
49627       nextPC = 8 + MATCH_p; 
49628       
49629       #line 348 "machine/pentium/disassembler.m"
49630       
49631 
49632               sprintf (str,  "SARB.Eb.Ib", DIS_EADDR8, DIS_I8);
49633 
49634       
49635 
49636       
49637       
49638       
49639     } 
49640     goto MATCH_finished_a; 
49641     
49642   MATCH_label_a812: (void)0; /*placeholder for label*/ 
49643     { 
49644       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49645       int /* [~128..127] */ i8 = 
49646         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
49647       nextPC = 7 + MATCH_p; 
49648       
49649       #line 348 "machine/pentium/disassembler.m"
49650       
49651 
49652               sprintf (str,  "SARB.Eb.Ib", DIS_EADDR8, DIS_I8);
49653 
49654       
49655 
49656       
49657       
49658       
49659     } 
49660     goto MATCH_finished_a; 
49661     
49662   MATCH_label_a813: (void)0; /*placeholder for label*/ 
49663     { 
49664       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49665       int /* [~128..127] */ i8 = 
49666         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
49667       nextPC = 3 + MATCH_p; 
49668       
49669       #line 342 "machine/pentium/disassembler.m"
49670       
49671 
49672               sprintf (str,  "ROLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
49673 
49674       
49675 
49676       
49677       
49678       
49679     } 
49680     goto MATCH_finished_a; 
49681     
49682   MATCH_label_a814: (void)0; /*placeholder for label*/ 
49683     { 
49684       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49685       int /* [~128..127] */ i8 = 
49686         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
49687       nextPC = 4 + MATCH_p; 
49688       
49689       #line 342 "machine/pentium/disassembler.m"
49690       
49691 
49692               sprintf (str,  "ROLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
49693 
49694       
49695 
49696       
49697       
49698       
49699     } 
49700     goto MATCH_finished_a; 
49701     
49702   MATCH_label_a815: (void)0; /*placeholder for label*/ 
49703     { 
49704       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49705       int /* [~128..127] */ i8 = 
49706         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
49707       nextPC = 8 + MATCH_p; 
49708       
49709       #line 342 "machine/pentium/disassembler.m"
49710       
49711 
49712               sprintf (str,  "ROLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
49713 
49714       
49715 
49716       
49717       
49718       
49719     } 
49720     goto MATCH_finished_a; 
49721     
49722   MATCH_label_a816: (void)0; /*placeholder for label*/ 
49723     { 
49724       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49725       int /* [~128..127] */ i8 = 
49726         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
49727       nextPC = 7 + MATCH_p; 
49728       
49729       #line 342 "machine/pentium/disassembler.m"
49730       
49731 
49732               sprintf (str,  "ROLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
49733 
49734       
49735 
49736       
49737       
49738       
49739     } 
49740     goto MATCH_finished_a; 
49741     
49742   MATCH_label_a817: (void)0; /*placeholder for label*/ 
49743     { 
49744       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49745       int /* [~128..127] */ i8 = 
49746         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
49747       nextPC = 3 + MATCH_p; 
49748       
49749       #line 336 "machine/pentium/disassembler.m"
49750       
49751 
49752               sprintf (str,  "RORB.Ev.Ibod", DIS_EADDR32, DIS_I8);
49753 
49754       
49755 
49756       
49757       
49758       
49759     } 
49760     goto MATCH_finished_a; 
49761     
49762   MATCH_label_a818: (void)0; /*placeholder for label*/ 
49763     { 
49764       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49765       int /* [~128..127] */ i8 = 
49766         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
49767       nextPC = 4 + MATCH_p; 
49768       
49769       #line 336 "machine/pentium/disassembler.m"
49770       
49771 
49772               sprintf (str,  "RORB.Ev.Ibod", DIS_EADDR32, DIS_I8);
49773 
49774       
49775 
49776       
49777       
49778       
49779     } 
49780     goto MATCH_finished_a; 
49781     
49782   MATCH_label_a819: (void)0; /*placeholder for label*/ 
49783     { 
49784       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49785       int /* [~128..127] */ i8 = 
49786         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
49787       nextPC = 8 + MATCH_p; 
49788       
49789       #line 336 "machine/pentium/disassembler.m"
49790       
49791 
49792               sprintf (str,  "RORB.Ev.Ibod", DIS_EADDR32, DIS_I8);
49793 
49794       
49795 
49796       
49797       
49798       
49799     } 
49800     goto MATCH_finished_a; 
49801     
49802   MATCH_label_a820: (void)0; /*placeholder for label*/ 
49803     { 
49804       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49805       int /* [~128..127] */ i8 = 
49806         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
49807       nextPC = 7 + MATCH_p; 
49808       
49809       #line 336 "machine/pentium/disassembler.m"
49810       
49811 
49812               sprintf (str,  "RORB.Ev.Ibod", DIS_EADDR32, DIS_I8);
49813 
49814       
49815 
49816       
49817       
49818       
49819     } 
49820     goto MATCH_finished_a; 
49821     
49822   MATCH_label_a821: (void)0; /*placeholder for label*/ 
49823     { 
49824       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49825       int /* [~128..127] */ i8 = 
49826         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
49827       nextPC = 3 + MATCH_p; 
49828       
49829       #line 330 "machine/pentium/disassembler.m"
49830       
49831 
49832               sprintf (str,  "RCLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
49833 
49834       
49835 
49836       
49837       
49838       
49839     } 
49840     goto MATCH_finished_a; 
49841     
49842   MATCH_label_a822: (void)0; /*placeholder for label*/ 
49843     { 
49844       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49845       int /* [~128..127] */ i8 = 
49846         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
49847       nextPC = 4 + MATCH_p; 
49848       
49849       #line 330 "machine/pentium/disassembler.m"
49850       
49851 
49852               sprintf (str,  "RCLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
49853 
49854       
49855 
49856       
49857       
49858       
49859     } 
49860     goto MATCH_finished_a; 
49861     
49862   MATCH_label_a823: (void)0; /*placeholder for label*/ 
49863     { 
49864       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49865       int /* [~128..127] */ i8 = 
49866         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
49867       nextPC = 8 + MATCH_p; 
49868       
49869       #line 330 "machine/pentium/disassembler.m"
49870       
49871 
49872               sprintf (str,  "RCLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
49873 
49874       
49875 
49876       
49877       
49878       
49879     } 
49880     goto MATCH_finished_a; 
49881     
49882   MATCH_label_a824: (void)0; /*placeholder for label*/ 
49883     { 
49884       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49885       int /* [~128..127] */ i8 = 
49886         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
49887       nextPC = 7 + MATCH_p; 
49888       
49889       #line 330 "machine/pentium/disassembler.m"
49890       
49891 
49892               sprintf (str,  "RCLB.Ev.Ibod", DIS_EADDR32, DIS_I8);
49893 
49894       
49895 
49896       
49897       
49898       
49899     } 
49900     goto MATCH_finished_a; 
49901     
49902   MATCH_label_a825: (void)0; /*placeholder for label*/ 
49903     { 
49904       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49905       int /* [~128..127] */ i8 = 
49906         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
49907       nextPC = 3 + MATCH_p; 
49908       
49909       #line 324 "machine/pentium/disassembler.m"
49910       
49911 
49912               sprintf (str,  "RCRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
49913 
49914       
49915 
49916       
49917       
49918       
49919     } 
49920     goto MATCH_finished_a; 
49921     
49922   MATCH_label_a826: (void)0; /*placeholder for label*/ 
49923     { 
49924       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49925       int /* [~128..127] */ i8 = 
49926         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
49927       nextPC = 4 + MATCH_p; 
49928       
49929       #line 324 "machine/pentium/disassembler.m"
49930       
49931 
49932               sprintf (str,  "RCRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
49933 
49934       
49935 
49936       
49937       
49938       
49939     } 
49940     goto MATCH_finished_a; 
49941     
49942   MATCH_label_a827: (void)0; /*placeholder for label*/ 
49943     { 
49944       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49945       int /* [~128..127] */ i8 = 
49946         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
49947       nextPC = 8 + MATCH_p; 
49948       
49949       #line 324 "machine/pentium/disassembler.m"
49950       
49951 
49952               sprintf (str,  "RCRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
49953 
49954       
49955 
49956       
49957       
49958       
49959     } 
49960     goto MATCH_finished_a; 
49961     
49962   MATCH_label_a828: (void)0; /*placeholder for label*/ 
49963     { 
49964       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49965       int /* [~128..127] */ i8 = 
49966         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
49967       nextPC = 7 + MATCH_p; 
49968       
49969       #line 324 "machine/pentium/disassembler.m"
49970       
49971 
49972               sprintf (str,  "RCRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
49973 
49974       
49975 
49976       
49977       
49978       
49979     } 
49980     goto MATCH_finished_a; 
49981     
49982   MATCH_label_a829: (void)0; /*placeholder for label*/ 
49983     { 
49984       unsigned Eaddr = 1 + addressToPC(MATCH_p);
49985       int /* [~128..127] */ i8 = 
49986         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
49987       nextPC = 3 + MATCH_p; 
49988       
49989       #line 318 "machine/pentium/disassembler.m"
49990       
49991 
49992               sprintf (str,  "SHLSALB.Ev.Ibod", DIS_EADDR32, DIS_I8);
49993 
49994       
49995 
49996       
49997       
49998       
49999     } 
50000     goto MATCH_finished_a; 
50001     
50002   MATCH_label_a830: (void)0; /*placeholder for label*/ 
50003     { 
50004       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50005       int /* [~128..127] */ i8 = 
50006         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
50007       nextPC = 4 + MATCH_p; 
50008       
50009       #line 318 "machine/pentium/disassembler.m"
50010       
50011 
50012               sprintf (str,  "SHLSALB.Ev.Ibod", DIS_EADDR32, DIS_I8);
50013 
50014       
50015 
50016       
50017       
50018       
50019     } 
50020     goto MATCH_finished_a; 
50021     
50022   MATCH_label_a831: (void)0; /*placeholder for label*/ 
50023     { 
50024       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50025       int /* [~128..127] */ i8 = 
50026         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
50027       nextPC = 8 + MATCH_p; 
50028       
50029       #line 318 "machine/pentium/disassembler.m"
50030       
50031 
50032               sprintf (str,  "SHLSALB.Ev.Ibod", DIS_EADDR32, DIS_I8);
50033 
50034       
50035 
50036       
50037       
50038       
50039     } 
50040     goto MATCH_finished_a; 
50041     
50042   MATCH_label_a832: (void)0; /*placeholder for label*/ 
50043     { 
50044       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50045       int /* [~128..127] */ i8 = 
50046         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
50047       nextPC = 7 + MATCH_p; 
50048       
50049       #line 318 "machine/pentium/disassembler.m"
50050       
50051 
50052               sprintf (str,  "SHLSALB.Ev.Ibod", DIS_EADDR32, DIS_I8);
50053 
50054       
50055 
50056       
50057       
50058       
50059     } 
50060     goto MATCH_finished_a; 
50061     
50062   MATCH_label_a833: (void)0; /*placeholder for label*/ 
50063     { 
50064       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50065       int /* [~128..127] */ i8 = 
50066         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
50067       nextPC = 3 + MATCH_p; 
50068       
50069       #line 312 "machine/pentium/disassembler.m"
50070       
50071 
50072               sprintf (str,  "SHRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
50073 
50074       
50075 
50076       
50077       
50078       
50079     } 
50080     goto MATCH_finished_a; 
50081     
50082   MATCH_label_a834: (void)0; /*placeholder for label*/ 
50083     { 
50084       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50085       int /* [~128..127] */ i8 = 
50086         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
50087       nextPC = 4 + MATCH_p; 
50088       
50089       #line 312 "machine/pentium/disassembler.m"
50090       
50091 
50092               sprintf (str,  "SHRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
50093 
50094       
50095 
50096       
50097       
50098       
50099     } 
50100     goto MATCH_finished_a; 
50101     
50102   MATCH_label_a835: (void)0; /*placeholder for label*/ 
50103     { 
50104       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50105       int /* [~128..127] */ i8 = 
50106         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
50107       nextPC = 8 + MATCH_p; 
50108       
50109       #line 312 "machine/pentium/disassembler.m"
50110       
50111 
50112               sprintf (str,  "SHRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
50113 
50114       
50115 
50116       
50117       
50118       
50119     } 
50120     goto MATCH_finished_a; 
50121     
50122   MATCH_label_a836: (void)0; /*placeholder for label*/ 
50123     { 
50124       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50125       int /* [~128..127] */ i8 = 
50126         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
50127       nextPC = 7 + MATCH_p; 
50128       
50129       #line 312 "machine/pentium/disassembler.m"
50130       
50131 
50132               sprintf (str,  "SHRB.Ev.Ibod", DIS_EADDR32, DIS_I8);
50133 
50134       
50135 
50136       
50137       
50138       
50139     } 
50140     goto MATCH_finished_a; 
50141     
50142   MATCH_label_a837: (void)0; /*placeholder for label*/ 
50143     { 
50144       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50145       int /* [~128..127] */ i8 = 
50146         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
50147       nextPC = 3 + MATCH_p; 
50148       
50149       #line 306 "machine/pentium/disassembler.m"
50150       
50151 
50152               sprintf (str,  "SARB.Ev.Ibod", DIS_EADDR32, DIS_I8);
50153 
50154       
50155 
50156       
50157       
50158       
50159     } 
50160     goto MATCH_finished_a; 
50161     
50162   MATCH_label_a838: (void)0; /*placeholder for label*/ 
50163     { 
50164       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50165       int /* [~128..127] */ i8 = 
50166         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
50167       nextPC = 4 + MATCH_p; 
50168       
50169       #line 306 "machine/pentium/disassembler.m"
50170       
50171 
50172               sprintf (str,  "SARB.Ev.Ibod", DIS_EADDR32, DIS_I8);
50173 
50174       
50175 
50176       
50177       
50178       
50179     } 
50180     goto MATCH_finished_a; 
50181     
50182   MATCH_label_a839: (void)0; /*placeholder for label*/ 
50183     { 
50184       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50185       int /* [~128..127] */ i8 = 
50186         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
50187       nextPC = 8 + MATCH_p; 
50188       
50189       #line 306 "machine/pentium/disassembler.m"
50190       
50191 
50192               sprintf (str,  "SARB.Ev.Ibod", DIS_EADDR32, DIS_I8);
50193 
50194       
50195 
50196       
50197       
50198       
50199     } 
50200     goto MATCH_finished_a; 
50201     
50202   MATCH_label_a840: (void)0; /*placeholder for label*/ 
50203     { 
50204       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50205       int /* [~128..127] */ i8 = 
50206         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
50207       nextPC = 7 + MATCH_p; 
50208       
50209       #line 306 "machine/pentium/disassembler.m"
50210       
50211 
50212               sprintf (str,  "SARB.Ev.Ibod", DIS_EADDR32, DIS_I8);
50213 
50214       
50215 
50216       
50217       
50218       
50219     } 
50220     goto MATCH_finished_a; 
50221     
50222   MATCH_label_a841: (void)0; /*placeholder for label*/ 
50223     { 
50224       unsigned Mem = 1 + addressToPC(MATCH_p);
50225       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
50226       nextPC = 3 + MATCH_p; 
50227       
50228       #line 772 "machine/pentium/disassembler.m"
50229       
50230 
50231               sprintf (str,  "LES", DIS_REG32, DIS_MEM);
50232 
50233       
50234 
50235       
50236       
50237       
50238     } 
50239     goto MATCH_finished_a; 
50240     
50241   MATCH_label_a842: (void)0; /*placeholder for label*/ 
50242     { 
50243       unsigned Mem = 1 + addressToPC(MATCH_p);
50244       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
50245       nextPC = 7 + MATCH_p; 
50246       
50247       #line 772 "machine/pentium/disassembler.m"
50248       
50249 
50250               sprintf (str,  "LES", DIS_REG32, DIS_MEM);
50251 
50252       
50253 
50254       
50255       
50256       
50257     } 
50258     goto MATCH_finished_a; 
50259     
50260   MATCH_label_a843: (void)0; /*placeholder for label*/ 
50261     { 
50262       unsigned Mem = 1 + addressToPC(MATCH_p);
50263       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
50264       nextPC = 6 + MATCH_p; 
50265       
50266       #line 772 "machine/pentium/disassembler.m"
50267       
50268 
50269               sprintf (str,  "LES", DIS_REG32, DIS_MEM);
50270 
50271       
50272 
50273       
50274       
50275       
50276     } 
50277     goto MATCH_finished_a; 
50278     
50279   MATCH_label_a844: (void)0; /*placeholder for label*/ 
50280     { 
50281       unsigned Mem = 1 + addressToPC(MATCH_p);
50282       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
50283       nextPC = 3 + MATCH_p; 
50284       
50285       #line 784 "machine/pentium/disassembler.m"
50286       
50287 
50288               sprintf (str,  "LDS", DIS_REG32, DIS_MEM);
50289 
50290       
50291 
50292       
50293       
50294       
50295     } 
50296     goto MATCH_finished_a; 
50297     
50298   MATCH_label_a845: (void)0; /*placeholder for label*/ 
50299     { 
50300       unsigned Mem = 1 + addressToPC(MATCH_p);
50301       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
50302       nextPC = 7 + MATCH_p; 
50303       
50304       #line 784 "machine/pentium/disassembler.m"
50305       
50306 
50307               sprintf (str,  "LDS", DIS_REG32, DIS_MEM);
50308 
50309       
50310 
50311       
50312       
50313       
50314     } 
50315     goto MATCH_finished_a; 
50316     
50317   MATCH_label_a846: (void)0; /*placeholder for label*/ 
50318     { 
50319       unsigned Mem = 1 + addressToPC(MATCH_p);
50320       unsigned reg = (MATCH_w_8_8 >> 3 & 0x7) /* reg_opcode at 8 */;
50321       nextPC = 6 + MATCH_p; 
50322       
50323       #line 784 "machine/pentium/disassembler.m"
50324       
50325 
50326               sprintf (str,  "LDS", DIS_REG32, DIS_MEM);
50327 
50328       
50329 
50330       
50331       
50332       
50333     } 
50334     goto MATCH_finished_a; 
50335     
50336   MATCH_label_a847: (void)0; /*placeholder for label*/ 
50337     { 
50338       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50339       int /* [~128..127] */ i8 = 
50340         sign_extend((MATCH_w_8_16 & 0xff) /* i8 at 16 */, 8);
50341       nextPC = 3 + MATCH_p; 
50342       
50343       #line 691 "machine/pentium/disassembler.m"
50344       
50345 
50346               sprintf (str,  "MOV.Eb.Ib", DIS_EADDR8, DIS_I8);
50347 
50348       
50349 
50350       
50351       
50352       
50353     } 
50354     goto MATCH_finished_a; 
50355     
50356   MATCH_label_a848: (void)0; /*placeholder for label*/ 
50357     { 
50358       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50359       int /* [~128..127] */ i8 = 
50360         sign_extend((MATCH_w_8_24 & 0xff) /* i8 at 24 */, 8);
50361       nextPC = 4 + MATCH_p; 
50362       
50363       #line 691 "machine/pentium/disassembler.m"
50364       
50365 
50366               sprintf (str,  "MOV.Eb.Ib", DIS_EADDR8, DIS_I8);
50367 
50368       
50369 
50370       
50371       
50372       
50373     } 
50374     goto MATCH_finished_a; 
50375     
50376   MATCH_label_a849: (void)0; /*placeholder for label*/ 
50377     { 
50378       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50379       int /* [~128..127] */ i8 = 
50380         sign_extend((MATCH_w_8_56 & 0xff) /* i8 at 56 */, 8);
50381       nextPC = 8 + MATCH_p; 
50382       
50383       #line 691 "machine/pentium/disassembler.m"
50384       
50385 
50386               sprintf (str,  "MOV.Eb.Ib", DIS_EADDR8, DIS_I8);
50387 
50388       
50389 
50390       
50391       
50392       
50393     } 
50394     goto MATCH_finished_a; 
50395     
50396   MATCH_label_a850: (void)0; /*placeholder for label*/ 
50397     { 
50398       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50399       int /* [~128..127] */ i8 = 
50400         sign_extend((MATCH_w_8_48 & 0xff) /* i8 at 48 */, 8);
50401       nextPC = 7 + MATCH_p; 
50402       
50403       #line 691 "machine/pentium/disassembler.m"
50404       
50405 
50406               sprintf (str,  "MOV.Eb.Ib", DIS_EADDR8, DIS_I8);
50407 
50408       
50409 
50410       
50411       
50412       
50413     } 
50414     goto MATCH_finished_a; 
50415     
50416   MATCH_label_a851: (void)0; /*placeholder for label*/ 
50417     { 
50418       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50419       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
50420       nextPC = 6 + MATCH_p; 
50421       
50422       #line 685 "machine/pentium/disassembler.m"
50423       
50424 
50425               sprintf (str,  "MOV.Eb.Ivod", DIS_EADDR32, DIS_I32);
50426 
50427       
50428 
50429       
50430       
50431       
50432     } 
50433     goto MATCH_finished_a; 
50434     
50435   MATCH_label_a852: (void)0; /*placeholder for label*/ 
50436     { 
50437       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50438       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
50439       nextPC = 7 + MATCH_p; 
50440       
50441       #line 685 "machine/pentium/disassembler.m"
50442       
50443 
50444               sprintf (str,  "MOV.Eb.Ivod", DIS_EADDR32, DIS_I32);
50445 
50446       
50447 
50448       
50449       
50450       
50451     } 
50452     goto MATCH_finished_a; 
50453     
50454   MATCH_label_a853: (void)0; /*placeholder for label*/ 
50455     { 
50456       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50457       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
50458       nextPC = 11 + MATCH_p; 
50459       
50460       #line 685 "machine/pentium/disassembler.m"
50461       
50462 
50463               sprintf (str,  "MOV.Eb.Ivod", DIS_EADDR32, DIS_I32);
50464 
50465       
50466 
50467       
50468       
50469       
50470     } 
50471     goto MATCH_finished_a; 
50472     
50473   MATCH_label_a854: (void)0; /*placeholder for label*/ 
50474     { 
50475       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50476       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
50477       nextPC = 10 + MATCH_p; 
50478       
50479       #line 685 "machine/pentium/disassembler.m"
50480       
50481 
50482               sprintf (str,  "MOV.Eb.Ivod", DIS_EADDR32, DIS_I32);
50483 
50484       
50485 
50486       
50487       
50488       
50489     } 
50490     goto MATCH_finished_a; 
50491     
50492   MATCH_label_a855: (void)0; /*placeholder for label*/ 
50493     { 
50494       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50495       nextPC = 2 + MATCH_p; 
50496       
50497       #line 492 "machine/pentium/disassembler.m"
50498       
50499 
50500               sprintf (str,  "ROLB.Eb.1", DIS_EADDR8);
50501 
50502       
50503 
50504       
50505       
50506       
50507     } 
50508     goto MATCH_finished_a; 
50509     
50510   MATCH_label_a856: (void)0; /*placeholder for label*/ 
50511     { 
50512       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50513       nextPC = 3 + MATCH_p; 
50514       
50515       #line 492 "machine/pentium/disassembler.m"
50516       
50517 
50518               sprintf (str,  "ROLB.Eb.1", DIS_EADDR8);
50519 
50520       
50521 
50522       
50523       
50524       
50525     } 
50526     goto MATCH_finished_a; 
50527     
50528   MATCH_label_a857: (void)0; /*placeholder for label*/ 
50529     { 
50530       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50531       nextPC = 7 + MATCH_p; 
50532       
50533       #line 492 "machine/pentium/disassembler.m"
50534       
50535 
50536               sprintf (str,  "ROLB.Eb.1", DIS_EADDR8);
50537 
50538       
50539 
50540       
50541       
50542       
50543     } 
50544     goto MATCH_finished_a; 
50545     
50546   MATCH_label_a858: (void)0; /*placeholder for label*/ 
50547     { 
50548       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50549       nextPC = 6 + MATCH_p; 
50550       
50551       #line 492 "machine/pentium/disassembler.m"
50552       
50553 
50554               sprintf (str,  "ROLB.Eb.1", DIS_EADDR8);
50555 
50556       
50557 
50558       
50559       
50560       
50561     } 
50562     goto MATCH_finished_a; 
50563     
50564   MATCH_label_a859: (void)0; /*placeholder for label*/ 
50565     { 
50566       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50567       nextPC = 2 + MATCH_p; 
50568       
50569       #line 486 "machine/pentium/disassembler.m"
50570       
50571 
50572               sprintf (str,  "RORB.Eb.1", DIS_EADDR8);
50573 
50574       
50575 
50576       
50577       
50578       
50579     } 
50580     goto MATCH_finished_a; 
50581     
50582   MATCH_label_a860: (void)0; /*placeholder for label*/ 
50583     { 
50584       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50585       nextPC = 3 + MATCH_p; 
50586       
50587       #line 486 "machine/pentium/disassembler.m"
50588       
50589 
50590               sprintf (str,  "RORB.Eb.1", DIS_EADDR8);
50591 
50592       
50593 
50594       
50595       
50596       
50597     } 
50598     goto MATCH_finished_a; 
50599     
50600   MATCH_label_a861: (void)0; /*placeholder for label*/ 
50601     { 
50602       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50603       nextPC = 7 + MATCH_p; 
50604       
50605       #line 486 "machine/pentium/disassembler.m"
50606       
50607 
50608               sprintf (str,  "RORB.Eb.1", DIS_EADDR8);
50609 
50610       
50611 
50612       
50613       
50614       
50615     } 
50616     goto MATCH_finished_a; 
50617     
50618   MATCH_label_a862: (void)0; /*placeholder for label*/ 
50619     { 
50620       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50621       nextPC = 6 + MATCH_p; 
50622       
50623       #line 486 "machine/pentium/disassembler.m"
50624       
50625 
50626               sprintf (str,  "RORB.Eb.1", DIS_EADDR8);
50627 
50628       
50629 
50630       
50631       
50632       
50633     } 
50634     goto MATCH_finished_a; 
50635     
50636   MATCH_label_a863: (void)0; /*placeholder for label*/ 
50637     { 
50638       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50639       nextPC = 2 + MATCH_p; 
50640       
50641       #line 480 "machine/pentium/disassembler.m"
50642       
50643 
50644               sprintf (str,  "RCLB.Eb.1", DIS_EADDR8);
50645 
50646       
50647 
50648       
50649       
50650       
50651     } 
50652     goto MATCH_finished_a; 
50653     
50654   MATCH_label_a864: (void)0; /*placeholder for label*/ 
50655     { 
50656       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50657       nextPC = 3 + MATCH_p; 
50658       
50659       #line 480 "machine/pentium/disassembler.m"
50660       
50661 
50662               sprintf (str,  "RCLB.Eb.1", DIS_EADDR8);
50663 
50664       
50665 
50666       
50667       
50668       
50669     } 
50670     goto MATCH_finished_a; 
50671     
50672   MATCH_label_a865: (void)0; /*placeholder for label*/ 
50673     { 
50674       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50675       nextPC = 7 + MATCH_p; 
50676       
50677       #line 480 "machine/pentium/disassembler.m"
50678       
50679 
50680               sprintf (str,  "RCLB.Eb.1", DIS_EADDR8);
50681 
50682       
50683 
50684       
50685       
50686       
50687     } 
50688     goto MATCH_finished_a; 
50689     
50690   MATCH_label_a866: (void)0; /*placeholder for label*/ 
50691     { 
50692       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50693       nextPC = 6 + MATCH_p; 
50694       
50695       #line 480 "machine/pentium/disassembler.m"
50696       
50697 
50698               sprintf (str,  "RCLB.Eb.1", DIS_EADDR8);
50699 
50700       
50701 
50702       
50703       
50704       
50705     } 
50706     goto MATCH_finished_a; 
50707     
50708   MATCH_label_a867: (void)0; /*placeholder for label*/ 
50709     { 
50710       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50711       nextPC = 2 + MATCH_p; 
50712       
50713       #line 474 "machine/pentium/disassembler.m"
50714       
50715 
50716               sprintf (str,  "RCRB.Eb.1", DIS_EADDR8);
50717 
50718       
50719 
50720       
50721       
50722       
50723     } 
50724     goto MATCH_finished_a; 
50725     
50726   MATCH_label_a868: (void)0; /*placeholder for label*/ 
50727     { 
50728       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50729       nextPC = 3 + MATCH_p; 
50730       
50731       #line 474 "machine/pentium/disassembler.m"
50732       
50733 
50734               sprintf (str,  "RCRB.Eb.1", DIS_EADDR8);
50735 
50736       
50737 
50738       
50739       
50740       
50741     } 
50742     goto MATCH_finished_a; 
50743     
50744   MATCH_label_a869: (void)0; /*placeholder for label*/ 
50745     { 
50746       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50747       nextPC = 7 + MATCH_p; 
50748       
50749       #line 474 "machine/pentium/disassembler.m"
50750       
50751 
50752               sprintf (str,  "RCRB.Eb.1", DIS_EADDR8);
50753 
50754       
50755 
50756       
50757       
50758       
50759     } 
50760     goto MATCH_finished_a; 
50761     
50762   MATCH_label_a870: (void)0; /*placeholder for label*/ 
50763     { 
50764       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50765       nextPC = 6 + MATCH_p; 
50766       
50767       #line 474 "machine/pentium/disassembler.m"
50768       
50769 
50770               sprintf (str,  "RCRB.Eb.1", DIS_EADDR8);
50771 
50772       
50773 
50774       
50775       
50776       
50777     } 
50778     goto MATCH_finished_a; 
50779     
50780   MATCH_label_a871: (void)0; /*placeholder for label*/ 
50781     { 
50782       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50783       nextPC = 2 + MATCH_p; 
50784       
50785       #line 468 "machine/pentium/disassembler.m"
50786       
50787 
50788               sprintf (str,  "SHLSALB.Eb.1", DIS_EADDR8);
50789 
50790       
50791 
50792       
50793       
50794       
50795     } 
50796     goto MATCH_finished_a; 
50797     
50798   MATCH_label_a872: (void)0; /*placeholder for label*/ 
50799     { 
50800       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50801       nextPC = 3 + MATCH_p; 
50802       
50803       #line 468 "machine/pentium/disassembler.m"
50804       
50805 
50806               sprintf (str,  "SHLSALB.Eb.1", DIS_EADDR8);
50807 
50808       
50809 
50810       
50811       
50812       
50813     } 
50814     goto MATCH_finished_a; 
50815     
50816   MATCH_label_a873: (void)0; /*placeholder for label*/ 
50817     { 
50818       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50819       nextPC = 7 + MATCH_p; 
50820       
50821       #line 468 "machine/pentium/disassembler.m"
50822       
50823 
50824               sprintf (str,  "SHLSALB.Eb.1", DIS_EADDR8);
50825 
50826       
50827 
50828       
50829       
50830       
50831     } 
50832     goto MATCH_finished_a; 
50833     
50834   MATCH_label_a874: (void)0; /*placeholder for label*/ 
50835     { 
50836       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50837       nextPC = 6 + MATCH_p; 
50838       
50839       #line 468 "machine/pentium/disassembler.m"
50840       
50841 
50842               sprintf (str,  "SHLSALB.Eb.1", DIS_EADDR8);
50843 
50844       
50845 
50846       
50847       
50848       
50849     } 
50850     goto MATCH_finished_a; 
50851     
50852   MATCH_label_a875: (void)0; /*placeholder for label*/ 
50853     { 
50854       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50855       nextPC = 2 + MATCH_p; 
50856       
50857       #line 462 "machine/pentium/disassembler.m"
50858       
50859 
50860               sprintf (str,  "SHRB.Eb.1", DIS_EADDR8);
50861 
50862       
50863 
50864       
50865       
50866       
50867     } 
50868     goto MATCH_finished_a; 
50869     
50870   MATCH_label_a876: (void)0; /*placeholder for label*/ 
50871     { 
50872       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50873       nextPC = 3 + MATCH_p; 
50874       
50875       #line 462 "machine/pentium/disassembler.m"
50876       
50877 
50878               sprintf (str,  "SHRB.Eb.1", DIS_EADDR8);
50879 
50880       
50881 
50882       
50883       
50884       
50885     } 
50886     goto MATCH_finished_a; 
50887     
50888   MATCH_label_a877: (void)0; /*placeholder for label*/ 
50889     { 
50890       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50891       nextPC = 7 + MATCH_p; 
50892       
50893       #line 462 "machine/pentium/disassembler.m"
50894       
50895 
50896               sprintf (str,  "SHRB.Eb.1", DIS_EADDR8);
50897 
50898       
50899 
50900       
50901       
50902       
50903     } 
50904     goto MATCH_finished_a; 
50905     
50906   MATCH_label_a878: (void)0; /*placeholder for label*/ 
50907     { 
50908       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50909       nextPC = 6 + MATCH_p; 
50910       
50911       #line 462 "machine/pentium/disassembler.m"
50912       
50913 
50914               sprintf (str,  "SHRB.Eb.1", DIS_EADDR8);
50915 
50916       
50917 
50918       
50919       
50920       
50921     } 
50922     goto MATCH_finished_a; 
50923     
50924   MATCH_label_a879: (void)0; /*placeholder for label*/ 
50925     { 
50926       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50927       nextPC = 2 + MATCH_p; 
50928       
50929       #line 456 "machine/pentium/disassembler.m"
50930       
50931 
50932               sprintf (str,  "SARB.Eb.1", DIS_EADDR16);
50933 
50934       
50935 
50936       
50937       
50938       
50939     } 
50940     goto MATCH_finished_a; 
50941     
50942   MATCH_label_a880: (void)0; /*placeholder for label*/ 
50943     { 
50944       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50945       nextPC = 3 + MATCH_p; 
50946       
50947       #line 456 "machine/pentium/disassembler.m"
50948       
50949 
50950               sprintf (str,  "SARB.Eb.1", DIS_EADDR16);
50951 
50952       
50953 
50954       
50955       
50956       
50957     } 
50958     goto MATCH_finished_a; 
50959     
50960   MATCH_label_a881: (void)0; /*placeholder for label*/ 
50961     { 
50962       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50963       nextPC = 7 + MATCH_p; 
50964       
50965       #line 456 "machine/pentium/disassembler.m"
50966       
50967 
50968               sprintf (str,  "SARB.Eb.1", DIS_EADDR16);
50969 
50970       
50971 
50972       
50973       
50974       
50975     } 
50976     goto MATCH_finished_a; 
50977     
50978   MATCH_label_a882: (void)0; /*placeholder for label*/ 
50979     { 
50980       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50981       nextPC = 6 + MATCH_p; 
50982       
50983       #line 456 "machine/pentium/disassembler.m"
50984       
50985 
50986               sprintf (str,  "SARB.Eb.1", DIS_EADDR16);
50987 
50988       
50989 
50990       
50991       
50992       
50993     } 
50994     goto MATCH_finished_a; 
50995     
50996   MATCH_label_a883: (void)0; /*placeholder for label*/ 
50997     { 
50998       unsigned Eaddr = 1 + addressToPC(MATCH_p);
50999       nextPC = 2 + MATCH_p; 
51000       
51001       #line 447 "machine/pentium/disassembler.m"
51002       
51003 
51004               sprintf (str,  "ROLB.Ev.1od", DIS_EADDR32);
51005 
51006       
51007 
51008       
51009       
51010       
51011     } 
51012     goto MATCH_finished_a; 
51013     
51014   MATCH_label_a884: (void)0; /*placeholder for label*/ 
51015     { 
51016       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51017       nextPC = 3 + MATCH_p; 
51018       
51019       #line 447 "machine/pentium/disassembler.m"
51020       
51021 
51022               sprintf (str,  "ROLB.Ev.1od", DIS_EADDR32);
51023 
51024       
51025 
51026       
51027       
51028       
51029     } 
51030     goto MATCH_finished_a; 
51031     
51032   MATCH_label_a885: (void)0; /*placeholder for label*/ 
51033     { 
51034       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51035       nextPC = 7 + MATCH_p; 
51036       
51037       #line 447 "machine/pentium/disassembler.m"
51038       
51039 
51040               sprintf (str,  "ROLB.Ev.1od", DIS_EADDR32);
51041 
51042       
51043 
51044       
51045       
51046       
51047     } 
51048     goto MATCH_finished_a; 
51049     
51050   MATCH_label_a886: (void)0; /*placeholder for label*/ 
51051     { 
51052       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51053       nextPC = 6 + MATCH_p; 
51054       
51055       #line 447 "machine/pentium/disassembler.m"
51056       
51057 
51058               sprintf (str,  "ROLB.Ev.1od", DIS_EADDR32);
51059 
51060       
51061 
51062       
51063       
51064       
51065     } 
51066     goto MATCH_finished_a; 
51067     
51068   MATCH_label_a887: (void)0; /*placeholder for label*/ 
51069     { 
51070       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51071       nextPC = 2 + MATCH_p; 
51072       
51073       #line 435 "machine/pentium/disassembler.m"
51074       
51075 
51076               sprintf (str,  "RORB.Ev.1od", DIS_EADDR32);
51077 
51078       
51079 
51080       
51081       
51082       
51083     } 
51084     goto MATCH_finished_a; 
51085     
51086   MATCH_label_a888: (void)0; /*placeholder for label*/ 
51087     { 
51088       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51089       nextPC = 3 + MATCH_p; 
51090       
51091       #line 435 "machine/pentium/disassembler.m"
51092       
51093 
51094               sprintf (str,  "RORB.Ev.1od", DIS_EADDR32);
51095 
51096       
51097 
51098       
51099       
51100       
51101     } 
51102     goto MATCH_finished_a; 
51103     
51104   MATCH_label_a889: (void)0; /*placeholder for label*/ 
51105     { 
51106       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51107       nextPC = 7 + MATCH_p; 
51108       
51109       #line 435 "machine/pentium/disassembler.m"
51110       
51111 
51112               sprintf (str,  "RORB.Ev.1od", DIS_EADDR32);
51113 
51114       
51115 
51116       
51117       
51118       
51119     } 
51120     goto MATCH_finished_a; 
51121     
51122   MATCH_label_a890: (void)0; /*placeholder for label*/ 
51123     { 
51124       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51125       nextPC = 6 + MATCH_p; 
51126       
51127       #line 435 "machine/pentium/disassembler.m"
51128       
51129 
51130               sprintf (str,  "RORB.Ev.1od", DIS_EADDR32);
51131 
51132       
51133 
51134       
51135       
51136       
51137     } 
51138     goto MATCH_finished_a; 
51139     
51140   MATCH_label_a891: (void)0; /*placeholder for label*/ 
51141     { 
51142       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51143       nextPC = 2 + MATCH_p; 
51144       
51145       #line 423 "machine/pentium/disassembler.m"
51146       
51147 
51148               sprintf (str,  "RCLB.Ev.1od", DIS_EADDR32);
51149 
51150       
51151 
51152       
51153       
51154       
51155     } 
51156     goto MATCH_finished_a; 
51157     
51158   MATCH_label_a892: (void)0; /*placeholder for label*/ 
51159     { 
51160       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51161       nextPC = 3 + MATCH_p; 
51162       
51163       #line 423 "machine/pentium/disassembler.m"
51164       
51165 
51166               sprintf (str,  "RCLB.Ev.1od", DIS_EADDR32);
51167 
51168       
51169 
51170       
51171       
51172       
51173     } 
51174     goto MATCH_finished_a; 
51175     
51176   MATCH_label_a893: (void)0; /*placeholder for label*/ 
51177     { 
51178       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51179       nextPC = 7 + MATCH_p; 
51180       
51181       #line 423 "machine/pentium/disassembler.m"
51182       
51183 
51184               sprintf (str,  "RCLB.Ev.1od", DIS_EADDR32);
51185 
51186       
51187 
51188       
51189       
51190       
51191     } 
51192     goto MATCH_finished_a; 
51193     
51194   MATCH_label_a894: (void)0; /*placeholder for label*/ 
51195     { 
51196       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51197       nextPC = 6 + MATCH_p; 
51198       
51199       #line 423 "machine/pentium/disassembler.m"
51200       
51201 
51202               sprintf (str,  "RCLB.Ev.1od", DIS_EADDR32);
51203 
51204       
51205 
51206       
51207       
51208       
51209     } 
51210     goto MATCH_finished_a; 
51211     
51212   MATCH_label_a895: (void)0; /*placeholder for label*/ 
51213     { 
51214       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51215       nextPC = 2 + MATCH_p; 
51216       
51217       #line 411 "machine/pentium/disassembler.m"
51218       
51219 
51220               sprintf (str,  "RCRB.Ev.1od", DIS_EADDR32);
51221 
51222       
51223 
51224       
51225       
51226       
51227     } 
51228     goto MATCH_finished_a; 
51229     
51230   MATCH_label_a896: (void)0; /*placeholder for label*/ 
51231     { 
51232       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51233       nextPC = 3 + MATCH_p; 
51234       
51235       #line 411 "machine/pentium/disassembler.m"
51236       
51237 
51238               sprintf (str,  "RCRB.Ev.1od", DIS_EADDR32);
51239 
51240       
51241 
51242       
51243       
51244       
51245     } 
51246     goto MATCH_finished_a; 
51247     
51248   MATCH_label_a897: (void)0; /*placeholder for label*/ 
51249     { 
51250       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51251       nextPC = 7 + MATCH_p; 
51252       
51253       #line 411 "machine/pentium/disassembler.m"
51254       
51255 
51256               sprintf (str,  "RCRB.Ev.1od", DIS_EADDR32);
51257 
51258       
51259 
51260       
51261       
51262       
51263     } 
51264     goto MATCH_finished_a; 
51265     
51266   MATCH_label_a898: (void)0; /*placeholder for label*/ 
51267     { 
51268       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51269       nextPC = 6 + MATCH_p; 
51270       
51271       #line 411 "machine/pentium/disassembler.m"
51272       
51273 
51274               sprintf (str,  "RCRB.Ev.1od", DIS_EADDR32);
51275 
51276       
51277 
51278       
51279       
51280       
51281     } 
51282     goto MATCH_finished_a; 
51283     
51284   MATCH_label_a899: (void)0; /*placeholder for label*/ 
51285     { 
51286       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51287       nextPC = 2 + MATCH_p; 
51288       
51289       #line 399 "machine/pentium/disassembler.m"
51290       
51291 
51292               sprintf (str,  "SHLSALB.Ev.1od", DIS_EADDR32);
51293 
51294       
51295 
51296       
51297       
51298       
51299     } 
51300     goto MATCH_finished_a; 
51301     
51302   MATCH_label_a900: (void)0; /*placeholder for label*/ 
51303     { 
51304       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51305       nextPC = 3 + MATCH_p; 
51306       
51307       #line 399 "machine/pentium/disassembler.m"
51308       
51309 
51310               sprintf (str,  "SHLSALB.Ev.1od", DIS_EADDR32);
51311 
51312       
51313 
51314       
51315       
51316       
51317     } 
51318     goto MATCH_finished_a; 
51319     
51320   MATCH_label_a901: (void)0; /*placeholder for label*/ 
51321     { 
51322       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51323       nextPC = 7 + MATCH_p; 
51324       
51325       #line 399 "machine/pentium/disassembler.m"
51326       
51327 
51328               sprintf (str,  "SHLSALB.Ev.1od", DIS_EADDR32);
51329 
51330       
51331 
51332       
51333       
51334       
51335     } 
51336     goto MATCH_finished_a; 
51337     
51338   MATCH_label_a902: (void)0; /*placeholder for label*/ 
51339     { 
51340       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51341       nextPC = 6 + MATCH_p; 
51342       
51343       #line 399 "machine/pentium/disassembler.m"
51344       
51345 
51346               sprintf (str,  "SHLSALB.Ev.1od", DIS_EADDR32);
51347 
51348       
51349 
51350       
51351       
51352       
51353     } 
51354     goto MATCH_finished_a; 
51355     
51356   MATCH_label_a903: (void)0; /*placeholder for label*/ 
51357     { 
51358       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51359       nextPC = 2 + MATCH_p; 
51360       
51361       #line 387 "machine/pentium/disassembler.m"
51362       
51363 
51364               sprintf (str,  "SHRB.Ev.1od", DIS_EADDR32);
51365 
51366       
51367 
51368       
51369       
51370       
51371     } 
51372     goto MATCH_finished_a; 
51373     
51374   MATCH_label_a904: (void)0; /*placeholder for label*/ 
51375     { 
51376       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51377       nextPC = 3 + MATCH_p; 
51378       
51379       #line 387 "machine/pentium/disassembler.m"
51380       
51381 
51382               sprintf (str,  "SHRB.Ev.1od", DIS_EADDR32);
51383 
51384       
51385 
51386       
51387       
51388       
51389     } 
51390     goto MATCH_finished_a; 
51391     
51392   MATCH_label_a905: (void)0; /*placeholder for label*/ 
51393     { 
51394       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51395       nextPC = 7 + MATCH_p; 
51396       
51397       #line 387 "machine/pentium/disassembler.m"
51398       
51399 
51400               sprintf (str,  "SHRB.Ev.1od", DIS_EADDR32);
51401 
51402       
51403 
51404       
51405       
51406       
51407     } 
51408     goto MATCH_finished_a; 
51409     
51410   MATCH_label_a906: (void)0; /*placeholder for label*/ 
51411     { 
51412       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51413       nextPC = 6 + MATCH_p; 
51414       
51415       #line 387 "machine/pentium/disassembler.m"
51416       
51417 
51418               sprintf (str,  "SHRB.Ev.1od", DIS_EADDR32);
51419 
51420       
51421 
51422       
51423       
51424       
51425     } 
51426     goto MATCH_finished_a; 
51427     
51428   MATCH_label_a907: (void)0; /*placeholder for label*/ 
51429     { 
51430       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51431       nextPC = 2 + MATCH_p; 
51432       
51433       #line 375 "machine/pentium/disassembler.m"
51434       
51435 
51436               sprintf (str,  "SARB.Ev.1od", DIS_EADDR32);
51437 
51438       
51439 
51440       
51441       
51442       
51443     } 
51444     goto MATCH_finished_a; 
51445     
51446   MATCH_label_a908: (void)0; /*placeholder for label*/ 
51447     { 
51448       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51449       nextPC = 3 + MATCH_p; 
51450       
51451       #line 375 "machine/pentium/disassembler.m"
51452       
51453 
51454               sprintf (str,  "SARB.Ev.1od", DIS_EADDR32);
51455 
51456       
51457 
51458       
51459       
51460       
51461     } 
51462     goto MATCH_finished_a; 
51463     
51464   MATCH_label_a909: (void)0; /*placeholder for label*/ 
51465     { 
51466       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51467       nextPC = 7 + MATCH_p; 
51468       
51469       #line 375 "machine/pentium/disassembler.m"
51470       
51471 
51472               sprintf (str,  "SARB.Ev.1od", DIS_EADDR32);
51473 
51474       
51475 
51476       
51477       
51478       
51479     } 
51480     goto MATCH_finished_a; 
51481     
51482   MATCH_label_a910: (void)0; /*placeholder for label*/ 
51483     { 
51484       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51485       nextPC = 6 + MATCH_p; 
51486       
51487       #line 375 "machine/pentium/disassembler.m"
51488       
51489 
51490               sprintf (str,  "SARB.Ev.1od", DIS_EADDR32);
51491 
51492       
51493 
51494       
51495       
51496       
51497     } 
51498     goto MATCH_finished_a; 
51499     
51500   MATCH_label_a911: (void)0; /*placeholder for label*/ 
51501     { 
51502       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51503       nextPC = 2 + MATCH_p; 
51504       
51505       #line 489 "machine/pentium/disassembler.m"
51506       
51507 
51508               sprintf (str,  "ROLB.Eb.CL", DIS_EADDR8);
51509 
51510       
51511 
51512       
51513       
51514       
51515     } 
51516     goto MATCH_finished_a; 
51517     
51518   MATCH_label_a912: (void)0; /*placeholder for label*/ 
51519     { 
51520       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51521       nextPC = 3 + MATCH_p; 
51522       
51523       #line 489 "machine/pentium/disassembler.m"
51524       
51525 
51526               sprintf (str,  "ROLB.Eb.CL", DIS_EADDR8);
51527 
51528       
51529 
51530       
51531       
51532       
51533     } 
51534     goto MATCH_finished_a; 
51535     
51536   MATCH_label_a913: (void)0; /*placeholder for label*/ 
51537     { 
51538       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51539       nextPC = 7 + MATCH_p; 
51540       
51541       #line 489 "machine/pentium/disassembler.m"
51542       
51543 
51544               sprintf (str,  "ROLB.Eb.CL", DIS_EADDR8);
51545 
51546       
51547 
51548       
51549       
51550       
51551     } 
51552     goto MATCH_finished_a; 
51553     
51554   MATCH_label_a914: (void)0; /*placeholder for label*/ 
51555     { 
51556       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51557       nextPC = 6 + MATCH_p; 
51558       
51559       #line 489 "machine/pentium/disassembler.m"
51560       
51561 
51562               sprintf (str,  "ROLB.Eb.CL", DIS_EADDR8);
51563 
51564       
51565 
51566       
51567       
51568       
51569     } 
51570     goto MATCH_finished_a; 
51571     
51572   MATCH_label_a915: (void)0; /*placeholder for label*/ 
51573     { 
51574       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51575       nextPC = 2 + MATCH_p; 
51576       
51577       #line 483 "machine/pentium/disassembler.m"
51578       
51579 
51580               sprintf (str,  "RORB.Eb.CL", DIS_EADDR8);
51581 
51582       
51583 
51584       
51585       
51586       
51587     } 
51588     goto MATCH_finished_a; 
51589     
51590   MATCH_label_a916: (void)0; /*placeholder for label*/ 
51591     { 
51592       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51593       nextPC = 3 + MATCH_p; 
51594       
51595       #line 483 "machine/pentium/disassembler.m"
51596       
51597 
51598               sprintf (str,  "RORB.Eb.CL", DIS_EADDR8);
51599 
51600       
51601 
51602       
51603       
51604       
51605     } 
51606     goto MATCH_finished_a; 
51607     
51608   MATCH_label_a917: (void)0; /*placeholder for label*/ 
51609     { 
51610       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51611       nextPC = 7 + MATCH_p; 
51612       
51613       #line 483 "machine/pentium/disassembler.m"
51614       
51615 
51616               sprintf (str,  "RORB.Eb.CL", DIS_EADDR8);
51617 
51618       
51619 
51620       
51621       
51622       
51623     } 
51624     goto MATCH_finished_a; 
51625     
51626   MATCH_label_a918: (void)0; /*placeholder for label*/ 
51627     { 
51628       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51629       nextPC = 6 + MATCH_p; 
51630       
51631       #line 483 "machine/pentium/disassembler.m"
51632       
51633 
51634               sprintf (str,  "RORB.Eb.CL", DIS_EADDR8);
51635 
51636       
51637 
51638       
51639       
51640       
51641     } 
51642     goto MATCH_finished_a; 
51643     
51644   MATCH_label_a919: (void)0; /*placeholder for label*/ 
51645     { 
51646       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51647       nextPC = 2 + MATCH_p; 
51648       
51649       #line 477 "machine/pentium/disassembler.m"
51650       
51651 
51652               sprintf (str,  "RCLB.Eb.CL", DIS_EADDR8);
51653 
51654       
51655 
51656       
51657       
51658       
51659     } 
51660     goto MATCH_finished_a; 
51661     
51662   MATCH_label_a920: (void)0; /*placeholder for label*/ 
51663     { 
51664       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51665       nextPC = 3 + MATCH_p; 
51666       
51667       #line 477 "machine/pentium/disassembler.m"
51668       
51669 
51670               sprintf (str,  "RCLB.Eb.CL", DIS_EADDR8);
51671 
51672       
51673 
51674       
51675       
51676       
51677     } 
51678     goto MATCH_finished_a; 
51679     
51680   MATCH_label_a921: (void)0; /*placeholder for label*/ 
51681     { 
51682       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51683       nextPC = 7 + MATCH_p; 
51684       
51685       #line 477 "machine/pentium/disassembler.m"
51686       
51687 
51688               sprintf (str,  "RCLB.Eb.CL", DIS_EADDR8);
51689 
51690       
51691 
51692       
51693       
51694       
51695     } 
51696     goto MATCH_finished_a; 
51697     
51698   MATCH_label_a922: (void)0; /*placeholder for label*/ 
51699     { 
51700       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51701       nextPC = 6 + MATCH_p; 
51702       
51703       #line 477 "machine/pentium/disassembler.m"
51704       
51705 
51706               sprintf (str,  "RCLB.Eb.CL", DIS_EADDR8);
51707 
51708       
51709 
51710       
51711       
51712       
51713     } 
51714     goto MATCH_finished_a; 
51715     
51716   MATCH_label_a923: (void)0; /*placeholder for label*/ 
51717     { 
51718       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51719       nextPC = 2 + MATCH_p; 
51720       
51721       #line 471 "machine/pentium/disassembler.m"
51722       
51723 
51724               sprintf (str,  "RCRB.Eb.CL", DIS_EADDR8);
51725 
51726       
51727 
51728       
51729       
51730       
51731     } 
51732     goto MATCH_finished_a; 
51733     
51734   MATCH_label_a924: (void)0; /*placeholder for label*/ 
51735     { 
51736       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51737       nextPC = 3 + MATCH_p; 
51738       
51739       #line 471 "machine/pentium/disassembler.m"
51740       
51741 
51742               sprintf (str,  "RCRB.Eb.CL", DIS_EADDR8);
51743 
51744       
51745 
51746       
51747       
51748       
51749     } 
51750     goto MATCH_finished_a; 
51751     
51752   MATCH_label_a925: (void)0; /*placeholder for label*/ 
51753     { 
51754       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51755       nextPC = 7 + MATCH_p; 
51756       
51757       #line 471 "machine/pentium/disassembler.m"
51758       
51759 
51760               sprintf (str,  "RCRB.Eb.CL", DIS_EADDR8);
51761 
51762       
51763 
51764       
51765       
51766       
51767     } 
51768     goto MATCH_finished_a; 
51769     
51770   MATCH_label_a926: (void)0; /*placeholder for label*/ 
51771     { 
51772       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51773       nextPC = 6 + MATCH_p; 
51774       
51775       #line 471 "machine/pentium/disassembler.m"
51776       
51777 
51778               sprintf (str,  "RCRB.Eb.CL", DIS_EADDR8);
51779 
51780       
51781 
51782       
51783       
51784       
51785     } 
51786     goto MATCH_finished_a; 
51787     
51788   MATCH_label_a927: (void)0; /*placeholder for label*/ 
51789     { 
51790       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51791       nextPC = 2 + MATCH_p; 
51792       
51793       #line 465 "machine/pentium/disassembler.m"
51794       
51795 
51796               sprintf (str,  "SHLSALB.Eb.CL", DIS_EADDR8);
51797 
51798       
51799 
51800       
51801       
51802       
51803     } 
51804     goto MATCH_finished_a; 
51805     
51806   MATCH_label_a928: (void)0; /*placeholder for label*/ 
51807     { 
51808       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51809       nextPC = 3 + MATCH_p; 
51810       
51811       #line 465 "machine/pentium/disassembler.m"
51812       
51813 
51814               sprintf (str,  "SHLSALB.Eb.CL", DIS_EADDR8);
51815 
51816       
51817 
51818       
51819       
51820       
51821     } 
51822     goto MATCH_finished_a; 
51823     
51824   MATCH_label_a929: (void)0; /*placeholder for label*/ 
51825     { 
51826       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51827       nextPC = 7 + MATCH_p; 
51828       
51829       #line 465 "machine/pentium/disassembler.m"
51830       
51831 
51832               sprintf (str,  "SHLSALB.Eb.CL", DIS_EADDR8);
51833 
51834       
51835 
51836       
51837       
51838       
51839     } 
51840     goto MATCH_finished_a; 
51841     
51842   MATCH_label_a930: (void)0; /*placeholder for label*/ 
51843     { 
51844       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51845       nextPC = 6 + MATCH_p; 
51846       
51847       #line 465 "machine/pentium/disassembler.m"
51848       
51849 
51850               sprintf (str,  "SHLSALB.Eb.CL", DIS_EADDR8);
51851 
51852       
51853 
51854       
51855       
51856       
51857     } 
51858     goto MATCH_finished_a; 
51859     
51860   MATCH_label_a931: (void)0; /*placeholder for label*/ 
51861     { 
51862       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51863       nextPC = 2 + MATCH_p; 
51864       
51865       #line 459 "machine/pentium/disassembler.m"
51866       
51867 
51868               sprintf (str,  "SHRB.Eb.CL", DIS_EADDR8);
51869 
51870       
51871 
51872       
51873       
51874       
51875     } 
51876     goto MATCH_finished_a; 
51877     
51878   MATCH_label_a932: (void)0; /*placeholder for label*/ 
51879     { 
51880       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51881       nextPC = 3 + MATCH_p; 
51882       
51883       #line 459 "machine/pentium/disassembler.m"
51884       
51885 
51886               sprintf (str,  "SHRB.Eb.CL", DIS_EADDR8);
51887 
51888       
51889 
51890       
51891       
51892       
51893     } 
51894     goto MATCH_finished_a; 
51895     
51896   MATCH_label_a933: (void)0; /*placeholder for label*/ 
51897     { 
51898       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51899       nextPC = 7 + MATCH_p; 
51900       
51901       #line 459 "machine/pentium/disassembler.m"
51902       
51903 
51904               sprintf (str,  "SHRB.Eb.CL", DIS_EADDR8);
51905 
51906       
51907 
51908       
51909       
51910       
51911     } 
51912     goto MATCH_finished_a; 
51913     
51914   MATCH_label_a934: (void)0; /*placeholder for label*/ 
51915     { 
51916       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51917       nextPC = 6 + MATCH_p; 
51918       
51919       #line 459 "machine/pentium/disassembler.m"
51920       
51921 
51922               sprintf (str,  "SHRB.Eb.CL", DIS_EADDR8);
51923 
51924       
51925 
51926       
51927       
51928       
51929     } 
51930     goto MATCH_finished_a; 
51931     
51932   MATCH_label_a935: (void)0; /*placeholder for label*/ 
51933     { 
51934       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51935       nextPC = 2 + MATCH_p; 
51936       
51937       #line 453 "machine/pentium/disassembler.m"
51938       
51939 
51940               sprintf (str,  "SARB.Eb.CL", DIS_EADDR32);
51941 
51942       
51943 
51944       
51945       
51946       
51947     } 
51948     goto MATCH_finished_a; 
51949     
51950   MATCH_label_a936: (void)0; /*placeholder for label*/ 
51951     { 
51952       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51953       nextPC = 3 + MATCH_p; 
51954       
51955       #line 453 "machine/pentium/disassembler.m"
51956       
51957 
51958               sprintf (str,  "SARB.Eb.CL", DIS_EADDR32);
51959 
51960       
51961 
51962       
51963       
51964       
51965     } 
51966     goto MATCH_finished_a; 
51967     
51968   MATCH_label_a937: (void)0; /*placeholder for label*/ 
51969     { 
51970       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51971       nextPC = 7 + MATCH_p; 
51972       
51973       #line 453 "machine/pentium/disassembler.m"
51974       
51975 
51976               sprintf (str,  "SARB.Eb.CL", DIS_EADDR32);
51977 
51978       
51979 
51980       
51981       
51982       
51983     } 
51984     goto MATCH_finished_a; 
51985     
51986   MATCH_label_a938: (void)0; /*placeholder for label*/ 
51987     { 
51988       unsigned Eaddr = 1 + addressToPC(MATCH_p);
51989       nextPC = 6 + MATCH_p; 
51990       
51991       #line 453 "machine/pentium/disassembler.m"
51992       
51993 
51994               sprintf (str,  "SARB.Eb.CL", DIS_EADDR32);
51995 
51996       
51997 
51998       
51999       
52000       
52001     } 
52002     goto MATCH_finished_a; 
52003     
52004   MATCH_label_a939: (void)0; /*placeholder for label*/ 
52005     { 
52006       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52007       nextPC = 2 + MATCH_p; 
52008       
52009       #line 441 "machine/pentium/disassembler.m"
52010       
52011 
52012               sprintf (str,  "ROLB.Ev.CLod", DIS_EADDR32);
52013 
52014       
52015 
52016       
52017       
52018       
52019     } 
52020     goto MATCH_finished_a; 
52021     
52022   MATCH_label_a940: (void)0; /*placeholder for label*/ 
52023     { 
52024       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52025       nextPC = 3 + MATCH_p; 
52026       
52027       #line 441 "machine/pentium/disassembler.m"
52028       
52029 
52030               sprintf (str,  "ROLB.Ev.CLod", DIS_EADDR32);
52031 
52032       
52033 
52034       
52035       
52036       
52037     } 
52038     goto MATCH_finished_a; 
52039     
52040   MATCH_label_a941: (void)0; /*placeholder for label*/ 
52041     { 
52042       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52043       nextPC = 7 + MATCH_p; 
52044       
52045       #line 441 "machine/pentium/disassembler.m"
52046       
52047 
52048               sprintf (str,  "ROLB.Ev.CLod", DIS_EADDR32);
52049 
52050       
52051 
52052       
52053       
52054       
52055     } 
52056     goto MATCH_finished_a; 
52057     
52058   MATCH_label_a942: (void)0; /*placeholder for label*/ 
52059     { 
52060       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52061       nextPC = 6 + MATCH_p; 
52062       
52063       #line 441 "machine/pentium/disassembler.m"
52064       
52065 
52066               sprintf (str,  "ROLB.Ev.CLod", DIS_EADDR32);
52067 
52068       
52069 
52070       
52071       
52072       
52073     } 
52074     goto MATCH_finished_a; 
52075     
52076   MATCH_label_a943: (void)0; /*placeholder for label*/ 
52077     { 
52078       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52079       nextPC = 2 + MATCH_p; 
52080       
52081       #line 429 "machine/pentium/disassembler.m"
52082       
52083 
52084               sprintf (str,  "RORB.Ev.CLod", DIS_EADDR32);
52085 
52086       
52087 
52088       
52089       
52090       
52091     } 
52092     goto MATCH_finished_a; 
52093     
52094   MATCH_label_a944: (void)0; /*placeholder for label*/ 
52095     { 
52096       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52097       nextPC = 3 + MATCH_p; 
52098       
52099       #line 429 "machine/pentium/disassembler.m"
52100       
52101 
52102               sprintf (str,  "RORB.Ev.CLod", DIS_EADDR32);
52103 
52104       
52105 
52106       
52107       
52108       
52109     } 
52110     goto MATCH_finished_a; 
52111     
52112   MATCH_label_a945: (void)0; /*placeholder for label*/ 
52113     { 
52114       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52115       nextPC = 7 + MATCH_p; 
52116       
52117       #line 429 "machine/pentium/disassembler.m"
52118       
52119 
52120               sprintf (str,  "RORB.Ev.CLod", DIS_EADDR32);
52121 
52122       
52123 
52124       
52125       
52126       
52127     } 
52128     goto MATCH_finished_a; 
52129     
52130   MATCH_label_a946: (void)0; /*placeholder for label*/ 
52131     { 
52132       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52133       nextPC = 6 + MATCH_p; 
52134       
52135       #line 429 "machine/pentium/disassembler.m"
52136       
52137 
52138               sprintf (str,  "RORB.Ev.CLod", DIS_EADDR32);
52139 
52140       
52141 
52142       
52143       
52144       
52145     } 
52146     goto MATCH_finished_a; 
52147     
52148   MATCH_label_a947: (void)0; /*placeholder for label*/ 
52149     { 
52150       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52151       nextPC = 2 + MATCH_p; 
52152       
52153       #line 417 "machine/pentium/disassembler.m"
52154       
52155 
52156               sprintf (str,  "RCLB.Ev.CLod", DIS_EADDR32);
52157 
52158       
52159 
52160       
52161       
52162       
52163     } 
52164     goto MATCH_finished_a; 
52165     
52166   MATCH_label_a948: (void)0; /*placeholder for label*/ 
52167     { 
52168       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52169       nextPC = 3 + MATCH_p; 
52170       
52171       #line 417 "machine/pentium/disassembler.m"
52172       
52173 
52174               sprintf (str,  "RCLB.Ev.CLod", DIS_EADDR32);
52175 
52176       
52177 
52178       
52179       
52180       
52181     } 
52182     goto MATCH_finished_a; 
52183     
52184   MATCH_label_a949: (void)0; /*placeholder for label*/ 
52185     { 
52186       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52187       nextPC = 7 + MATCH_p; 
52188       
52189       #line 417 "machine/pentium/disassembler.m"
52190       
52191 
52192               sprintf (str,  "RCLB.Ev.CLod", DIS_EADDR32);
52193 
52194       
52195 
52196       
52197       
52198       
52199     } 
52200     goto MATCH_finished_a; 
52201     
52202   MATCH_label_a950: (void)0; /*placeholder for label*/ 
52203     { 
52204       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52205       nextPC = 6 + MATCH_p; 
52206       
52207       #line 417 "machine/pentium/disassembler.m"
52208       
52209 
52210               sprintf (str,  "RCLB.Ev.CLod", DIS_EADDR32);
52211 
52212       
52213 
52214       
52215       
52216       
52217     } 
52218     goto MATCH_finished_a; 
52219     
52220   MATCH_label_a951: (void)0; /*placeholder for label*/ 
52221     { 
52222       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52223       nextPC = 2 + MATCH_p; 
52224       
52225       #line 405 "machine/pentium/disassembler.m"
52226       
52227 
52228               sprintf (str,  "RCRB.Ev.CLod", DIS_EADDR32);
52229 
52230       
52231 
52232       
52233       
52234       
52235     } 
52236     goto MATCH_finished_a; 
52237     
52238   MATCH_label_a952: (void)0; /*placeholder for label*/ 
52239     { 
52240       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52241       nextPC = 3 + MATCH_p; 
52242       
52243       #line 405 "machine/pentium/disassembler.m"
52244       
52245 
52246               sprintf (str,  "RCRB.Ev.CLod", DIS_EADDR32);
52247 
52248       
52249 
52250       
52251       
52252       
52253     } 
52254     goto MATCH_finished_a; 
52255     
52256   MATCH_label_a953: (void)0; /*placeholder for label*/ 
52257     { 
52258       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52259       nextPC = 7 + MATCH_p; 
52260       
52261       #line 405 "machine/pentium/disassembler.m"
52262       
52263 
52264               sprintf (str,  "RCRB.Ev.CLod", DIS_EADDR32);
52265 
52266       
52267 
52268       
52269       
52270       
52271     } 
52272     goto MATCH_finished_a; 
52273     
52274   MATCH_label_a954: (void)0; /*placeholder for label*/ 
52275     { 
52276       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52277       nextPC = 6 + MATCH_p; 
52278       
52279       #line 405 "machine/pentium/disassembler.m"
52280       
52281 
52282               sprintf (str,  "RCRB.Ev.CLod", DIS_EADDR32);
52283 
52284       
52285 
52286       
52287       
52288       
52289     } 
52290     goto MATCH_finished_a; 
52291     
52292   MATCH_label_a955: (void)0; /*placeholder for label*/ 
52293     { 
52294       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52295       nextPC = 2 + MATCH_p; 
52296       
52297       #line 393 "machine/pentium/disassembler.m"
52298       
52299 
52300               sprintf (str,  "SHLSALB.Ev.CLod", DIS_EADDR32);
52301 
52302       
52303 
52304       
52305       
52306       
52307     } 
52308     goto MATCH_finished_a; 
52309     
52310   MATCH_label_a956: (void)0; /*placeholder for label*/ 
52311     { 
52312       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52313       nextPC = 3 + MATCH_p; 
52314       
52315       #line 393 "machine/pentium/disassembler.m"
52316       
52317 
52318               sprintf (str,  "SHLSALB.Ev.CLod", DIS_EADDR32);
52319 
52320       
52321 
52322       
52323       
52324       
52325     } 
52326     goto MATCH_finished_a; 
52327     
52328   MATCH_label_a957: (void)0; /*placeholder for label*/ 
52329     { 
52330       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52331       nextPC = 7 + MATCH_p; 
52332       
52333       #line 393 "machine/pentium/disassembler.m"
52334       
52335 
52336               sprintf (str,  "SHLSALB.Ev.CLod", DIS_EADDR32);
52337 
52338       
52339 
52340       
52341       
52342       
52343     } 
52344     goto MATCH_finished_a; 
52345     
52346   MATCH_label_a958: (void)0; /*placeholder for label*/ 
52347     { 
52348       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52349       nextPC = 6 + MATCH_p; 
52350       
52351       #line 393 "machine/pentium/disassembler.m"
52352       
52353 
52354               sprintf (str,  "SHLSALB.Ev.CLod", DIS_EADDR32);
52355 
52356       
52357 
52358       
52359       
52360       
52361     } 
52362     goto MATCH_finished_a; 
52363     
52364   MATCH_label_a959: (void)0; /*placeholder for label*/ 
52365     { 
52366       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52367       nextPC = 2 + MATCH_p; 
52368       
52369       #line 381 "machine/pentium/disassembler.m"
52370       
52371 
52372               sprintf (str,  "SHRB.Ev.CLod", DIS_EADDR32);
52373 
52374       
52375 
52376       
52377       
52378       
52379     } 
52380     goto MATCH_finished_a; 
52381     
52382   MATCH_label_a960: (void)0; /*placeholder for label*/ 
52383     { 
52384       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52385       nextPC = 3 + MATCH_p; 
52386       
52387       #line 381 "machine/pentium/disassembler.m"
52388       
52389 
52390               sprintf (str,  "SHRB.Ev.CLod", DIS_EADDR32);
52391 
52392       
52393 
52394       
52395       
52396       
52397     } 
52398     goto MATCH_finished_a; 
52399     
52400   MATCH_label_a961: (void)0; /*placeholder for label*/ 
52401     { 
52402       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52403       nextPC = 7 + MATCH_p; 
52404       
52405       #line 381 "machine/pentium/disassembler.m"
52406       
52407 
52408               sprintf (str,  "SHRB.Ev.CLod", DIS_EADDR32);
52409 
52410       
52411 
52412       
52413       
52414       
52415     } 
52416     goto MATCH_finished_a; 
52417     
52418   MATCH_label_a962: (void)0; /*placeholder for label*/ 
52419     { 
52420       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52421       nextPC = 6 + MATCH_p; 
52422       
52423       #line 381 "machine/pentium/disassembler.m"
52424       
52425 
52426               sprintf (str,  "SHRB.Ev.CLod", DIS_EADDR32);
52427 
52428       
52429 
52430       
52431       
52432       
52433     } 
52434     goto MATCH_finished_a; 
52435     
52436   MATCH_label_a963: (void)0; /*placeholder for label*/ 
52437     { 
52438       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52439       nextPC = 2 + MATCH_p; 
52440       
52441       #line 369 "machine/pentium/disassembler.m"
52442       
52443 
52444               sprintf (str,  "SARB.Ev.CLod", DIS_EADDR32);
52445 
52446       
52447 
52448       
52449       
52450       
52451     } 
52452     goto MATCH_finished_a; 
52453     
52454   MATCH_label_a964: (void)0; /*placeholder for label*/ 
52455     { 
52456       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52457       nextPC = 3 + MATCH_p; 
52458       
52459       #line 369 "machine/pentium/disassembler.m"
52460       
52461 
52462               sprintf (str,  "SARB.Ev.CLod", DIS_EADDR32);
52463 
52464       
52465 
52466       
52467       
52468       
52469     } 
52470     goto MATCH_finished_a; 
52471     
52472   MATCH_label_a965: (void)0; /*placeholder for label*/ 
52473     { 
52474       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52475       nextPC = 7 + MATCH_p; 
52476       
52477       #line 369 "machine/pentium/disassembler.m"
52478       
52479 
52480               sprintf (str,  "SARB.Ev.CLod", DIS_EADDR32);
52481 
52482       
52483 
52484       
52485       
52486       
52487     } 
52488     goto MATCH_finished_a; 
52489     
52490   MATCH_label_a966: (void)0; /*placeholder for label*/ 
52491     { 
52492       unsigned Eaddr = 1 + addressToPC(MATCH_p);
52493       nextPC = 6 + MATCH_p; 
52494       
52495       #line 369 "machine/pentium/disassembler.m"
52496       
52497 
52498               sprintf (str,  "SARB.Ev.CLod", DIS_EADDR32);
52499 
52500       
52501 
52502       
52503       
52504       
52505     } 
52506     goto MATCH_finished_a; 
52507     
52508   MATCH_label_a967: (void)0; /*placeholder for label*/ 
52509     { 
52510       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52511       nextPC = 3 + MATCH_p; 
52512       
52513       #line 1430 "machine/pentium/disassembler.m"
52514       
52515 
52516               sprintf (str,  "FADD.R32", DIS_MEM32);
52517 
52518       
52519 
52520       
52521       
52522       
52523     } 
52524     goto MATCH_finished_a; 
52525     
52526   MATCH_label_a968: (void)0; /*placeholder for label*/ 
52527     { 
52528       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52529       nextPC = 7 + MATCH_p; 
52530       
52531       #line 1430 "machine/pentium/disassembler.m"
52532       
52533 
52534               sprintf (str,  "FADD.R32", DIS_MEM32);
52535 
52536       
52537 
52538       
52539       
52540       
52541     } 
52542     goto MATCH_finished_a; 
52543     
52544   MATCH_label_a969: (void)0; /*placeholder for label*/ 
52545     { 
52546       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52547       nextPC = 6 + MATCH_p; 
52548       
52549       #line 1430 "machine/pentium/disassembler.m"
52550       
52551 
52552               sprintf (str,  "FADD.R32", DIS_MEM32);
52553 
52554       
52555 
52556       
52557       
52558       
52559     } 
52560     goto MATCH_finished_a; 
52561     
52562   MATCH_label_a970: (void)0; /*placeholder for label*/ 
52563     { 
52564       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52565       nextPC = 3 + MATCH_p; 
52566       
52567       #line 1624 "machine/pentium/disassembler.m"
52568       
52569 
52570               sprintf (str,  "FMUL.R32", DIS_MEM32);
52571 
52572       
52573 
52574       
52575       
52576       
52577     } 
52578     goto MATCH_finished_a; 
52579     
52580   MATCH_label_a971: (void)0; /*placeholder for label*/ 
52581     { 
52582       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52583       nextPC = 7 + MATCH_p; 
52584       
52585       #line 1624 "machine/pentium/disassembler.m"
52586       
52587 
52588               sprintf (str,  "FMUL.R32", DIS_MEM32);
52589 
52590       
52591 
52592       
52593       
52594       
52595     } 
52596     goto MATCH_finished_a; 
52597     
52598   MATCH_label_a972: (void)0; /*placeholder for label*/ 
52599     { 
52600       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52601       nextPC = 6 + MATCH_p; 
52602       
52603       #line 1624 "machine/pentium/disassembler.m"
52604       
52605 
52606               sprintf (str,  "FMUL.R32", DIS_MEM32);
52607 
52608       
52609 
52610       
52611       
52612       
52613     } 
52614     goto MATCH_finished_a; 
52615     
52616   MATCH_label_a973: (void)0; /*placeholder for label*/ 
52617     { 
52618       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52619       nextPC = 3 + MATCH_p; 
52620       
52621       #line 1463 "machine/pentium/disassembler.m"
52622       
52623 
52624               sprintf (str,  "FCOM.R32", DIS_MEM32);
52625 
52626       
52627 
52628       
52629       
52630       
52631     } 
52632     goto MATCH_finished_a; 
52633     
52634   MATCH_label_a974: (void)0; /*placeholder for label*/ 
52635     { 
52636       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52637       nextPC = 7 + MATCH_p; 
52638       
52639       #line 1463 "machine/pentium/disassembler.m"
52640       
52641 
52642               sprintf (str,  "FCOM.R32", DIS_MEM32);
52643 
52644       
52645 
52646       
52647       
52648       
52649     } 
52650     goto MATCH_finished_a; 
52651     
52652   MATCH_label_a975: (void)0; /*placeholder for label*/ 
52653     { 
52654       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52655       nextPC = 6 + MATCH_p; 
52656       
52657       #line 1463 "machine/pentium/disassembler.m"
52658       
52659 
52660               sprintf (str,  "FCOM.R32", DIS_MEM32);
52661 
52662       
52663 
52664       
52665       
52666       
52667     } 
52668     goto MATCH_finished_a; 
52669     
52670   MATCH_label_a976: (void)0; /*placeholder for label*/ 
52671     { 
52672       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52673       nextPC = 3 + MATCH_p; 
52674       
52675       #line 1475 "machine/pentium/disassembler.m"
52676       
52677 
52678               sprintf (str,  "FCOMP.R32", DIS_MEM32);
52679 
52680       
52681 
52682       
52683       
52684       
52685     } 
52686     goto MATCH_finished_a; 
52687     
52688   MATCH_label_a977: (void)0; /*placeholder for label*/ 
52689     { 
52690       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52691       nextPC = 7 + MATCH_p; 
52692       
52693       #line 1475 "machine/pentium/disassembler.m"
52694       
52695 
52696               sprintf (str,  "FCOMP.R32", DIS_MEM32);
52697 
52698       
52699 
52700       
52701       
52702       
52703     } 
52704     goto MATCH_finished_a; 
52705     
52706   MATCH_label_a978: (void)0; /*placeholder for label*/ 
52707     { 
52708       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52709       nextPC = 6 + MATCH_p; 
52710       
52711       #line 1475 "machine/pentium/disassembler.m"
52712       
52713 
52714               sprintf (str,  "FCOMP.R32", DIS_MEM32);
52715 
52716       
52717 
52718       
52719       
52720       
52721     } 
52722     goto MATCH_finished_a; 
52723     
52724   MATCH_label_a979: (void)0; /*placeholder for label*/ 
52725     { 
52726       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52727       nextPC = 3 + MATCH_p; 
52728       
52729       #line 1714 "machine/pentium/disassembler.m"
52730       
52731 
52732               sprintf (str,  "FSUB.R32", DIS_MEM32);
52733 
52734       
52735 
52736       
52737       
52738       
52739     } 
52740     goto MATCH_finished_a; 
52741     
52742   MATCH_label_a980: (void)0; /*placeholder for label*/ 
52743     { 
52744       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52745       nextPC = 7 + MATCH_p; 
52746       
52747       #line 1714 "machine/pentium/disassembler.m"
52748       
52749 
52750               sprintf (str,  "FSUB.R32", DIS_MEM32);
52751 
52752       
52753 
52754       
52755       
52756       
52757     } 
52758     goto MATCH_finished_a; 
52759     
52760   MATCH_label_a981: (void)0; /*placeholder for label*/ 
52761     { 
52762       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52763       nextPC = 6 + MATCH_p; 
52764       
52765       #line 1714 "machine/pentium/disassembler.m"
52766       
52767 
52768               sprintf (str,  "FSUB.R32", DIS_MEM32);
52769 
52770       
52771 
52772       
52773       
52774       
52775     } 
52776     goto MATCH_finished_a; 
52777     
52778   MATCH_label_a982: (void)0; /*placeholder for label*/ 
52779     { 
52780       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52781       nextPC = 3 + MATCH_p; 
52782       
52783       #line 1735 "machine/pentium/disassembler.m"
52784       
52785 
52786               sprintf (str,  "FSUBR.R32", DIS_MEM32);
52787 
52788       
52789 
52790       
52791       
52792       
52793     } 
52794     goto MATCH_finished_a; 
52795     
52796   MATCH_label_a983: (void)0; /*placeholder for label*/ 
52797     { 
52798       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52799       nextPC = 7 + MATCH_p; 
52800       
52801       #line 1735 "machine/pentium/disassembler.m"
52802       
52803 
52804               sprintf (str,  "FSUBR.R32", DIS_MEM32);
52805 
52806       
52807 
52808       
52809       
52810       
52811     } 
52812     goto MATCH_finished_a; 
52813     
52814   MATCH_label_a984: (void)0; /*placeholder for label*/ 
52815     { 
52816       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52817       nextPC = 6 + MATCH_p; 
52818       
52819       #line 1735 "machine/pentium/disassembler.m"
52820       
52821 
52822               sprintf (str,  "FSUBR.R32", DIS_MEM32);
52823 
52824       
52825 
52826       
52827       
52828       
52829     } 
52830     goto MATCH_finished_a; 
52831     
52832   MATCH_label_a985: (void)0; /*placeholder for label*/ 
52833     { 
52834       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52835       nextPC = 3 + MATCH_p; 
52836       
52837       #line 1508 "machine/pentium/disassembler.m"
52838       
52839 
52840               sprintf (str,  "FDIV.R32", DIS_MEM32);
52841 
52842       
52843 
52844       
52845       
52846       
52847     } 
52848     goto MATCH_finished_a; 
52849     
52850   MATCH_label_a986: (void)0; /*placeholder for label*/ 
52851     { 
52852       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52853       nextPC = 7 + MATCH_p; 
52854       
52855       #line 1508 "machine/pentium/disassembler.m"
52856       
52857 
52858               sprintf (str,  "FDIV.R32", DIS_MEM32);
52859 
52860       
52861 
52862       
52863       
52864       
52865     } 
52866     goto MATCH_finished_a; 
52867     
52868   MATCH_label_a987: (void)0; /*placeholder for label*/ 
52869     { 
52870       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52871       nextPC = 6 + MATCH_p; 
52872       
52873       #line 1508 "machine/pentium/disassembler.m"
52874       
52875 
52876               sprintf (str,  "FDIV.R32", DIS_MEM32);
52877 
52878       
52879 
52880       
52881       
52882       
52883     } 
52884     goto MATCH_finished_a; 
52885     
52886   MATCH_label_a988: (void)0; /*placeholder for label*/ 
52887     { 
52888       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52889       nextPC = 3 + MATCH_p; 
52890       
52891       #line 1529 "machine/pentium/disassembler.m"
52892       
52893 
52894               sprintf (str,  "FDIVR.R32", DIS_MEM32);
52895 
52896       
52897 
52898       
52899       
52900       
52901     } 
52902     goto MATCH_finished_a; 
52903     
52904   MATCH_label_a989: (void)0; /*placeholder for label*/ 
52905     { 
52906       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52907       nextPC = 7 + MATCH_p; 
52908       
52909       #line 1529 "machine/pentium/disassembler.m"
52910       
52911 
52912               sprintf (str,  "FDIVR.R32", DIS_MEM32);
52913 
52914       
52915 
52916       
52917       
52918       
52919     } 
52920     goto MATCH_finished_a; 
52921     
52922   MATCH_label_a990: (void)0; /*placeholder for label*/ 
52923     { 
52924       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52925       nextPC = 6 + MATCH_p; 
52926       
52927       #line 1529 "machine/pentium/disassembler.m"
52928       
52929 
52930               sprintf (str,  "FDIVR.R32", DIS_MEM32);
52931 
52932       
52933 
52934       
52935       
52936       
52937     } 
52938     goto MATCH_finished_a; 
52939     
52940   MATCH_label_a991: (void)0; /*placeholder for label*/ 
52941     { 
52942       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52943       nextPC = 3 + MATCH_p; 
52944       
52945       #line 1580 "machine/pentium/disassembler.m"
52946       
52947 
52948               sprintf (str,  "FLD.lsR32", DIS_MEM32);
52949 
52950       
52951 
52952       
52953       
52954       
52955     } 
52956     goto MATCH_finished_a; 
52957     
52958   MATCH_label_a992: (void)0; /*placeholder for label*/ 
52959     { 
52960       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52961       nextPC = 7 + MATCH_p; 
52962       
52963       #line 1580 "machine/pentium/disassembler.m"
52964       
52965 
52966               sprintf (str,  "FLD.lsR32", DIS_MEM32);
52967 
52968       
52969 
52970       
52971       
52972       
52973     } 
52974     goto MATCH_finished_a; 
52975     
52976   MATCH_label_a993: (void)0; /*placeholder for label*/ 
52977     { 
52978       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52979       nextPC = 6 + MATCH_p; 
52980       
52981       #line 1580 "machine/pentium/disassembler.m"
52982       
52983 
52984               sprintf (str,  "FLD.lsR32", DIS_MEM32);
52985 
52986       
52987 
52988       
52989       
52990       
52991     } 
52992     goto MATCH_finished_a; 
52993     
52994   MATCH_label_a994: (void)0; /*placeholder for label*/ 
52995     { 
52996       unsigned Mem32 = 1 + addressToPC(MATCH_p);
52997       nextPC = 3 + MATCH_p; 
52998       
52999       #line 1681 "machine/pentium/disassembler.m"
53000       
53001 
53002               sprintf (str,  "FST.lsR32", DIS_MEM32);
53003 
53004       
53005 
53006       
53007       
53008       
53009     } 
53010     goto MATCH_finished_a; 
53011     
53012   MATCH_label_a995: (void)0; /*placeholder for label*/ 
53013     { 
53014       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53015       nextPC = 7 + MATCH_p; 
53016       
53017       #line 1681 "machine/pentium/disassembler.m"
53018       
53019 
53020               sprintf (str,  "FST.lsR32", DIS_MEM32);
53021 
53022       
53023 
53024       
53025       
53026       
53027     } 
53028     goto MATCH_finished_a; 
53029     
53030   MATCH_label_a996: (void)0; /*placeholder for label*/ 
53031     { 
53032       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53033       nextPC = 6 + MATCH_p; 
53034       
53035       #line 1681 "machine/pentium/disassembler.m"
53036       
53037 
53038               sprintf (str,  "FST.lsR32", DIS_MEM32);
53039 
53040       
53041 
53042       
53043       
53044       
53045     } 
53046     goto MATCH_finished_a; 
53047     
53048   MATCH_label_a997: (void)0; /*placeholder for label*/ 
53049     { 
53050       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53051       nextPC = 3 + MATCH_p; 
53052       
53053       #line 1687 "machine/pentium/disassembler.m"
53054       
53055 
53056               sprintf (str,  "FSTP.lsR32", DIS_MEM32);
53057 
53058       
53059 
53060       
53061       
53062       
53063     } 
53064     goto MATCH_finished_a; 
53065     
53066   MATCH_label_a998: (void)0; /*placeholder for label*/ 
53067     { 
53068       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53069       nextPC = 7 + MATCH_p; 
53070       
53071       #line 1687 "machine/pentium/disassembler.m"
53072       
53073 
53074               sprintf (str,  "FSTP.lsR32", DIS_MEM32);
53075 
53076       
53077 
53078       
53079       
53080       
53081     } 
53082     goto MATCH_finished_a; 
53083     
53084   MATCH_label_a999: (void)0; /*placeholder for label*/ 
53085     { 
53086       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53087       nextPC = 6 + MATCH_p; 
53088       
53089       #line 1687 "machine/pentium/disassembler.m"
53090       
53091 
53092               sprintf (str,  "FSTP.lsR32", DIS_MEM32);
53093 
53094       
53095 
53096       
53097       
53098       
53099     } 
53100     goto MATCH_finished_a; 
53101     
53102   MATCH_label_a1000: (void)0; /*placeholder for label*/ 
53103     { 
53104       unsigned Mem = 1 + addressToPC(MATCH_p);
53105       nextPC = 3 + MATCH_p; 
53106       
53107       #line 1621 "machine/pentium/disassembler.m"
53108       
53109 
53110               sprintf (str,  "FLDENV", DIS_MEM);
53111 
53112       
53113 
53114       
53115       
53116       
53117     } 
53118     goto MATCH_finished_a; 
53119     
53120   MATCH_label_a1001: (void)0; /*placeholder for label*/ 
53121     { 
53122       unsigned Mem = 1 + addressToPC(MATCH_p);
53123       nextPC = 7 + MATCH_p; 
53124       
53125       #line 1621 "machine/pentium/disassembler.m"
53126       
53127 
53128               sprintf (str,  "FLDENV", DIS_MEM);
53129 
53130       
53131 
53132       
53133       
53134       
53135     } 
53136     goto MATCH_finished_a; 
53137     
53138   MATCH_label_a1002: (void)0; /*placeholder for label*/ 
53139     { 
53140       unsigned Mem = 1 + addressToPC(MATCH_p);
53141       nextPC = 6 + MATCH_p; 
53142       
53143       #line 1621 "machine/pentium/disassembler.m"
53144       
53145 
53146               sprintf (str,  "FLDENV", DIS_MEM);
53147 
53148       
53149 
53150       
53151       
53152       
53153     } 
53154     goto MATCH_finished_a; 
53155     
53156   MATCH_label_a1003: (void)0; /*placeholder for label*/ 
53157     { 
53158       unsigned Mem16 = 1 + addressToPC(MATCH_p);
53159       nextPC = 3 + MATCH_p; 
53160       
53161       #line 1618 "machine/pentium/disassembler.m"
53162       
53163 
53164               sprintf (str,  "FLDCW", DIS_MEM16);
53165 
53166       
53167 
53168       
53169       
53170       
53171     } 
53172     goto MATCH_finished_a; 
53173     
53174   MATCH_label_a1004: (void)0; /*placeholder for label*/ 
53175     { 
53176       unsigned Mem16 = 1 + addressToPC(MATCH_p);
53177       nextPC = 7 + MATCH_p; 
53178       
53179       #line 1618 "machine/pentium/disassembler.m"
53180       
53181 
53182               sprintf (str,  "FLDCW", DIS_MEM16);
53183 
53184       
53185 
53186       
53187       
53188       
53189     } 
53190     goto MATCH_finished_a; 
53191     
53192   MATCH_label_a1005: (void)0; /*placeholder for label*/ 
53193     { 
53194       unsigned Mem16 = 1 + addressToPC(MATCH_p);
53195       nextPC = 6 + MATCH_p; 
53196       
53197       #line 1618 "machine/pentium/disassembler.m"
53198       
53199 
53200               sprintf (str,  "FLDCW", DIS_MEM16);
53201 
53202       
53203 
53204       
53205       
53206       
53207     } 
53208     goto MATCH_finished_a; 
53209     
53210   MATCH_label_a1006: (void)0; /*placeholder for label*/ 
53211     { 
53212       unsigned Mem = 1 + addressToPC(MATCH_p);
53213       nextPC = 3 + MATCH_p; 
53214       
53215       #line 1705 "machine/pentium/disassembler.m"
53216       
53217 
53218               sprintf (str,  "FSTENV", DIS_MEM);
53219 
53220       
53221 
53222       
53223       
53224       
53225     } 
53226     goto MATCH_finished_a; 
53227     
53228   MATCH_label_a1007: (void)0; /*placeholder for label*/ 
53229     { 
53230       unsigned Mem = 1 + addressToPC(MATCH_p);
53231       nextPC = 7 + MATCH_p; 
53232       
53233       #line 1705 "machine/pentium/disassembler.m"
53234       
53235 
53236               sprintf (str,  "FSTENV", DIS_MEM);
53237 
53238       
53239 
53240       
53241       
53242       
53243     } 
53244     goto MATCH_finished_a; 
53245     
53246   MATCH_label_a1008: (void)0; /*placeholder for label*/ 
53247     { 
53248       unsigned Mem = 1 + addressToPC(MATCH_p);
53249       nextPC = 6 + MATCH_p; 
53250       
53251       #line 1705 "machine/pentium/disassembler.m"
53252       
53253 
53254               sprintf (str,  "FSTENV", DIS_MEM);
53255 
53256       
53257 
53258       
53259       
53260       
53261     } 
53262     goto MATCH_finished_a; 
53263     
53264   MATCH_label_a1009: (void)0; /*placeholder for label*/ 
53265     { 
53266       unsigned Mem16 = 1 + addressToPC(MATCH_p);
53267       nextPC = 3 + MATCH_p; 
53268       
53269       #line 1702 "machine/pentium/disassembler.m"
53270       
53271 
53272               sprintf (str,  "FSTCW", DIS_MEM16);
53273 
53274       
53275 
53276       
53277       
53278       
53279     } 
53280     goto MATCH_finished_a; 
53281     
53282   MATCH_label_a1010: (void)0; /*placeholder for label*/ 
53283     { 
53284       unsigned Mem16 = 1 + addressToPC(MATCH_p);
53285       nextPC = 7 + MATCH_p; 
53286       
53287       #line 1702 "machine/pentium/disassembler.m"
53288       
53289 
53290               sprintf (str,  "FSTCW", DIS_MEM16);
53291 
53292       
53293 
53294       
53295       
53296       
53297     } 
53298     goto MATCH_finished_a; 
53299     
53300   MATCH_label_a1011: (void)0; /*placeholder for label*/ 
53301     { 
53302       unsigned Mem16 = 1 + addressToPC(MATCH_p);
53303       nextPC = 6 + MATCH_p; 
53304       
53305       #line 1702 "machine/pentium/disassembler.m"
53306       
53307 
53308               sprintf (str,  "FSTCW", DIS_MEM16);
53309 
53310       
53311 
53312       
53313       
53314       
53315     } 
53316     goto MATCH_finished_a; 
53317     
53318   MATCH_label_a1012: (void)0; /*placeholder for label*/ 
53319     { 
53320       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53321       nextPC = 3 + MATCH_p; 
53322       
53323       #line 1445 "machine/pentium/disassembler.m"
53324       
53325 
53326               sprintf (str,  "FIADD.I32", DIS_MEM32);
53327 
53328       
53329 
53330       
53331       
53332       
53333     } 
53334     goto MATCH_finished_a; 
53335     
53336   MATCH_label_a1013: (void)0; /*placeholder for label*/ 
53337     { 
53338       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53339       nextPC = 7 + MATCH_p; 
53340       
53341       #line 1445 "machine/pentium/disassembler.m"
53342       
53343 
53344               sprintf (str,  "FIADD.I32", DIS_MEM32);
53345 
53346       
53347 
53348       
53349       
53350       
53351     } 
53352     goto MATCH_finished_a; 
53353     
53354   MATCH_label_a1014: (void)0; /*placeholder for label*/ 
53355     { 
53356       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53357       nextPC = 6 + MATCH_p; 
53358       
53359       #line 1445 "machine/pentium/disassembler.m"
53360       
53361 
53362               sprintf (str,  "FIADD.I32", DIS_MEM32);
53363 
53364       
53365 
53366       
53367       
53368       
53369     } 
53370     goto MATCH_finished_a; 
53371     
53372   MATCH_label_a1015: (void)0; /*placeholder for label*/ 
53373     { 
53374       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53375       nextPC = 3 + MATCH_p; 
53376       
53377       #line 1639 "machine/pentium/disassembler.m"
53378       
53379 
53380               sprintf (str,  "FIMUL.I32", DIS_MEM32);
53381 
53382       
53383 
53384       
53385       
53386       
53387     } 
53388     goto MATCH_finished_a; 
53389     
53390   MATCH_label_a1016: (void)0; /*placeholder for label*/ 
53391     { 
53392       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53393       nextPC = 7 + MATCH_p; 
53394       
53395       #line 1639 "machine/pentium/disassembler.m"
53396       
53397 
53398               sprintf (str,  "FIMUL.I32", DIS_MEM32);
53399 
53400       
53401 
53402       
53403       
53404       
53405     } 
53406     goto MATCH_finished_a; 
53407     
53408   MATCH_label_a1017: (void)0; /*placeholder for label*/ 
53409     { 
53410       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53411       nextPC = 6 + MATCH_p; 
53412       
53413       #line 1639 "machine/pentium/disassembler.m"
53414       
53415 
53416               sprintf (str,  "FIMUL.I32", DIS_MEM32);
53417 
53418       
53419 
53420       
53421       
53422       
53423     } 
53424     goto MATCH_finished_a; 
53425     
53426   MATCH_label_a1018: (void)0; /*placeholder for label*/ 
53427     { 
53428       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53429       nextPC = 3 + MATCH_p; 
53430       
53431       #line 1469 "machine/pentium/disassembler.m"
53432       
53433 
53434               sprintf (str,  "FICOM.I32", DIS_MEM32);
53435 
53436       
53437 
53438       
53439       
53440       
53441     } 
53442     goto MATCH_finished_a; 
53443     
53444   MATCH_label_a1019: (void)0; /*placeholder for label*/ 
53445     { 
53446       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53447       nextPC = 7 + MATCH_p; 
53448       
53449       #line 1469 "machine/pentium/disassembler.m"
53450       
53451 
53452               sprintf (str,  "FICOM.I32", DIS_MEM32);
53453 
53454       
53455 
53456       
53457       
53458       
53459     } 
53460     goto MATCH_finished_a; 
53461     
53462   MATCH_label_a1020: (void)0; /*placeholder for label*/ 
53463     { 
53464       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53465       nextPC = 6 + MATCH_p; 
53466       
53467       #line 1469 "machine/pentium/disassembler.m"
53468       
53469 
53470               sprintf (str,  "FICOM.I32", DIS_MEM32);
53471 
53472       
53473 
53474       
53475       
53476       
53477     } 
53478     goto MATCH_finished_a; 
53479     
53480   MATCH_label_a1021: (void)0; /*placeholder for label*/ 
53481     { 
53482       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53483       nextPC = 3 + MATCH_p; 
53484       
53485       #line 1487 "machine/pentium/disassembler.m"
53486       
53487 
53488               sprintf (str,  "FICOMP.I32", DIS_MEM32);
53489 
53490       
53491 
53492       
53493       
53494       
53495     } 
53496     goto MATCH_finished_a; 
53497     
53498   MATCH_label_a1022: (void)0; /*placeholder for label*/ 
53499     { 
53500       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53501       nextPC = 7 + MATCH_p; 
53502       
53503       #line 1487 "machine/pentium/disassembler.m"
53504       
53505 
53506               sprintf (str,  "FICOMP.I32", DIS_MEM32);
53507 
53508       
53509 
53510       
53511       
53512       
53513     } 
53514     goto MATCH_finished_a; 
53515     
53516   MATCH_label_a1023: (void)0; /*placeholder for label*/ 
53517     { 
53518       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53519       nextPC = 6 + MATCH_p; 
53520       
53521       #line 1487 "machine/pentium/disassembler.m"
53522       
53523 
53524               sprintf (str,  "FICOMP.I32", DIS_MEM32);
53525 
53526       
53527 
53528       
53529       
53530       
53531     } 
53532     goto MATCH_finished_a; 
53533     
53534   MATCH_label_a1024: (void)0; /*placeholder for label*/ 
53535     { 
53536       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53537       nextPC = 3 + MATCH_p; 
53538       
53539       #line 1726 "machine/pentium/disassembler.m"
53540       
53541 
53542               sprintf (str,  "FISUB.I32", DIS_MEM32);
53543 
53544       
53545 
53546       
53547       
53548       
53549     } 
53550     goto MATCH_finished_a; 
53551     
53552   MATCH_label_a1025: (void)0; /*placeholder for label*/ 
53553     { 
53554       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53555       nextPC = 7 + MATCH_p; 
53556       
53557       #line 1726 "machine/pentium/disassembler.m"
53558       
53559 
53560               sprintf (str,  "FISUB.I32", DIS_MEM32);
53561 
53562       
53563 
53564       
53565       
53566       
53567     } 
53568     goto MATCH_finished_a; 
53569     
53570   MATCH_label_a1026: (void)0; /*placeholder for label*/ 
53571     { 
53572       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53573       nextPC = 6 + MATCH_p; 
53574       
53575       #line 1726 "machine/pentium/disassembler.m"
53576       
53577 
53578               sprintf (str,  "FISUB.I32", DIS_MEM32);
53579 
53580       
53581 
53582       
53583       
53584       
53585     } 
53586     goto MATCH_finished_a; 
53587     
53588   MATCH_label_a1027: (void)0; /*placeholder for label*/ 
53589     { 
53590       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53591       nextPC = 3 + MATCH_p; 
53592       
53593       #line 1747 "machine/pentium/disassembler.m"
53594       
53595 
53596               sprintf (str,  "FISUBR.I32", DIS_MEM32);
53597 
53598       
53599 
53600       
53601       
53602       
53603     } 
53604     goto MATCH_finished_a; 
53605     
53606   MATCH_label_a1028: (void)0; /*placeholder for label*/ 
53607     { 
53608       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53609       nextPC = 7 + MATCH_p; 
53610       
53611       #line 1747 "machine/pentium/disassembler.m"
53612       
53613 
53614               sprintf (str,  "FISUBR.I32", DIS_MEM32);
53615 
53616       
53617 
53618       
53619       
53620       
53621     } 
53622     goto MATCH_finished_a; 
53623     
53624   MATCH_label_a1029: (void)0; /*placeholder for label*/ 
53625     { 
53626       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53627       nextPC = 6 + MATCH_p; 
53628       
53629       #line 1747 "machine/pentium/disassembler.m"
53630       
53631 
53632               sprintf (str,  "FISUBR.I32", DIS_MEM32);
53633 
53634       
53635 
53636       
53637       
53638       
53639     } 
53640     goto MATCH_finished_a; 
53641     
53642   MATCH_label_a1030: (void)0; /*placeholder for label*/ 
53643     { 
53644       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53645       nextPC = 3 + MATCH_p; 
53646       
53647       #line 1523 "machine/pentium/disassembler.m"
53648       
53649 
53650               sprintf (str,  "FIDIV.I32", DIS_MEM32);
53651 
53652       
53653 
53654       
53655       
53656       
53657     } 
53658     goto MATCH_finished_a; 
53659     
53660   MATCH_label_a1031: (void)0; /*placeholder for label*/ 
53661     { 
53662       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53663       nextPC = 7 + MATCH_p; 
53664       
53665       #line 1523 "machine/pentium/disassembler.m"
53666       
53667 
53668               sprintf (str,  "FIDIV.I32", DIS_MEM32);
53669 
53670       
53671 
53672       
53673       
53674       
53675     } 
53676     goto MATCH_finished_a; 
53677     
53678   MATCH_label_a1032: (void)0; /*placeholder for label*/ 
53679     { 
53680       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53681       nextPC = 6 + MATCH_p; 
53682       
53683       #line 1523 "machine/pentium/disassembler.m"
53684       
53685 
53686               sprintf (str,  "FIDIV.I32", DIS_MEM32);
53687 
53688       
53689 
53690       
53691       
53692       
53693     } 
53694     goto MATCH_finished_a; 
53695     
53696   MATCH_label_a1033: (void)0; /*placeholder for label*/ 
53697     { 
53698       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53699       nextPC = 3 + MATCH_p; 
53700       
53701       #line 1541 "machine/pentium/disassembler.m"
53702       
53703 
53704               sprintf (str,  "FIDIVR.I32", DIS_MEM32);
53705 
53706       
53707 
53708       
53709       
53710       
53711     } 
53712     goto MATCH_finished_a; 
53713     
53714   MATCH_label_a1034: (void)0; /*placeholder for label*/ 
53715     { 
53716       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53717       nextPC = 7 + MATCH_p; 
53718       
53719       #line 1541 "machine/pentium/disassembler.m"
53720       
53721 
53722               sprintf (str,  "FIDIVR.I32", DIS_MEM32);
53723 
53724       
53725 
53726       
53727       
53728       
53729     } 
53730     goto MATCH_finished_a; 
53731     
53732   MATCH_label_a1035: (void)0; /*placeholder for label*/ 
53733     { 
53734       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53735       nextPC = 6 + MATCH_p; 
53736       
53737       #line 1541 "machine/pentium/disassembler.m"
53738       
53739 
53740               sprintf (str,  "FIDIVR.I32", DIS_MEM32);
53741 
53742       
53743 
53744       
53745       
53746       
53747     } 
53748     goto MATCH_finished_a; 
53749     
53750   MATCH_label_a1036: (void)0; /*placeholder for label*/ 
53751     { 
53752       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53753       nextPC = 3 + MATCH_p; 
53754       
53755       #line 1556 "machine/pentium/disassembler.m"
53756       
53757 
53758               sprintf (str,  "FILD.lsI32", DIS_MEM32);
53759 
53760       
53761 
53762       
53763       
53764       
53765     } 
53766     goto MATCH_finished_a; 
53767     
53768   MATCH_label_a1037: (void)0; /*placeholder for label*/ 
53769     { 
53770       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53771       nextPC = 7 + MATCH_p; 
53772       
53773       #line 1556 "machine/pentium/disassembler.m"
53774       
53775 
53776               sprintf (str,  "FILD.lsI32", DIS_MEM32);
53777 
53778       
53779 
53780       
53781       
53782       
53783     } 
53784     goto MATCH_finished_a; 
53785     
53786   MATCH_label_a1038: (void)0; /*placeholder for label*/ 
53787     { 
53788       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53789       nextPC = 6 + MATCH_p; 
53790       
53791       #line 1556 "machine/pentium/disassembler.m"
53792       
53793 
53794               sprintf (str,  "FILD.lsI32", DIS_MEM32);
53795 
53796       
53797 
53798       
53799       
53800       
53801     } 
53802     goto MATCH_finished_a; 
53803     
53804   MATCH_label_a1039: (void)0; /*placeholder for label*/ 
53805     { 
53806       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53807       nextPC = 3 + MATCH_p; 
53808       
53809       #line 1568 "machine/pentium/disassembler.m"
53810       
53811 
53812               sprintf (str,  "FIST.lsI32", DIS_MEM32);
53813 
53814       
53815 
53816       
53817       
53818       
53819     } 
53820     goto MATCH_finished_a; 
53821     
53822   MATCH_label_a1040: (void)0; /*placeholder for label*/ 
53823     { 
53824       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53825       nextPC = 7 + MATCH_p; 
53826       
53827       #line 1568 "machine/pentium/disassembler.m"
53828       
53829 
53830               sprintf (str,  "FIST.lsI32", DIS_MEM32);
53831 
53832       
53833 
53834       
53835       
53836       
53837     } 
53838     goto MATCH_finished_a; 
53839     
53840   MATCH_label_a1041: (void)0; /*placeholder for label*/ 
53841     { 
53842       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53843       nextPC = 6 + MATCH_p; 
53844       
53845       #line 1568 "machine/pentium/disassembler.m"
53846       
53847 
53848               sprintf (str,  "FIST.lsI32", DIS_MEM32);
53849 
53850       
53851 
53852       
53853       
53854       
53855     } 
53856     goto MATCH_finished_a; 
53857     
53858   MATCH_label_a1042: (void)0; /*placeholder for label*/ 
53859     { 
53860       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53861       nextPC = 3 + MATCH_p; 
53862       
53863       #line 1574 "machine/pentium/disassembler.m"
53864       
53865 
53866               sprintf (str,  "FISTP.lsI32", DIS_MEM32);
53867 
53868       
53869 
53870       
53871       
53872       
53873     } 
53874     goto MATCH_finished_a; 
53875     
53876   MATCH_label_a1043: (void)0; /*placeholder for label*/ 
53877     { 
53878       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53879       nextPC = 7 + MATCH_p; 
53880       
53881       #line 1574 "machine/pentium/disassembler.m"
53882       
53883 
53884               sprintf (str,  "FISTP.lsI32", DIS_MEM32);
53885 
53886       
53887 
53888       
53889       
53890       
53891     } 
53892     goto MATCH_finished_a; 
53893     
53894   MATCH_label_a1044: (void)0; /*placeholder for label*/ 
53895     { 
53896       unsigned Mem32 = 1 + addressToPC(MATCH_p);
53897       nextPC = 6 + MATCH_p; 
53898       
53899       #line 1574 "machine/pentium/disassembler.m"
53900       
53901 
53902               sprintf (str,  "FISTP.lsI32", DIS_MEM32);
53903 
53904       
53905 
53906       
53907       
53908       
53909     } 
53910     goto MATCH_finished_a; 
53911     
53912   MATCH_label_a1045: (void)0; /*placeholder for label*/ 
53913     { 
53914       unsigned Mem80 = 1 + addressToPC(MATCH_p);
53915       nextPC = 3 + MATCH_p; 
53916       
53917       #line 1586 "machine/pentium/disassembler.m"
53918       
53919 
53920               sprintf (str,  "FLD80", DIS_MEM80);
53921 
53922       
53923 
53924       /* This is a bit tricky. The FPUSH logically comes between the read of STi and
53925 
53926       # the write to ST0. In particular, FLD ST0 is supposed to duplicate the TOS.
53927 
53928       # This problem only happens with this load instruction, so there is a work
53929 
53930       # around here that gives us the SSL a value of i that is one more than in
53931 
53932       # the instruction */
53933 
53934       
53935       
53936       
53937     } 
53938     goto MATCH_finished_a; 
53939     
53940   MATCH_label_a1046: (void)0; /*placeholder for label*/ 
53941     { 
53942       unsigned Mem80 = 1 + addressToPC(MATCH_p);
53943       nextPC = 7 + MATCH_p; 
53944       
53945       #line 1586 "machine/pentium/disassembler.m"
53946       
53947 
53948               sprintf (str,  "FLD80", DIS_MEM80);
53949 
53950       
53951 
53952       /* This is a bit tricky. The FPUSH logically comes between the read of STi and
53953 
53954       # the write to ST0. In particular, FLD ST0 is supposed to duplicate the TOS.
53955 
53956       # This problem only happens with this load instruction, so there is a work
53957 
53958       # around here that gives us the SSL a value of i that is one more than in
53959 
53960       # the instruction */
53961 
53962       
53963       
53964       
53965     } 
53966     goto MATCH_finished_a; 
53967     
53968   MATCH_label_a1047: (void)0; /*placeholder for label*/ 
53969     { 
53970       unsigned Mem80 = 1 + addressToPC(MATCH_p);
53971       nextPC = 6 + MATCH_p; 
53972       
53973       #line 1586 "machine/pentium/disassembler.m"
53974       
53975 
53976               sprintf (str,  "FLD80", DIS_MEM80);
53977 
53978       
53979 
53980       /* This is a bit tricky. The FPUSH logically comes between the read of STi and
53981 
53982       # the write to ST0. In particular, FLD ST0 is supposed to duplicate the TOS.
53983 
53984       # This problem only happens with this load instruction, so there is a work
53985 
53986       # around here that gives us the SSL a value of i that is one more than in
53987 
53988       # the instruction */
53989 
53990       
53991       
53992       
53993     } 
53994     goto MATCH_finished_a; 
53995     
53996   MATCH_label_a1048: (void)0; /*placeholder for label*/ 
53997     { 
53998       unsigned Mem80 = 1 + addressToPC(MATCH_p);
53999       nextPC = 3 + MATCH_p; 
54000       
54001       #line 1693 "machine/pentium/disassembler.m"
54002       
54003 
54004               sprintf (str,  "FSTP80", DIS_MEM80);
54005 
54006       
54007 
54008       
54009       
54010       
54011     } 
54012     goto MATCH_finished_a; 
54013     
54014   MATCH_label_a1049: (void)0; /*placeholder for label*/ 
54015     { 
54016       unsigned Mem80 = 1 + addressToPC(MATCH_p);
54017       nextPC = 7 + MATCH_p; 
54018       
54019       #line 1693 "machine/pentium/disassembler.m"
54020       
54021 
54022               sprintf (str,  "FSTP80", DIS_MEM80);
54023 
54024       
54025 
54026       
54027       
54028       
54029     } 
54030     goto MATCH_finished_a; 
54031     
54032   MATCH_label_a1050: (void)0; /*placeholder for label*/ 
54033     { 
54034       unsigned Mem80 = 1 + addressToPC(MATCH_p);
54035       nextPC = 6 + MATCH_p; 
54036       
54037       #line 1693 "machine/pentium/disassembler.m"
54038       
54039 
54040               sprintf (str,  "FSTP80", DIS_MEM80);
54041 
54042       
54043 
54044       
54045       
54046       
54047     } 
54048     goto MATCH_finished_a; 
54049     
54050   MATCH_label_a1051: (void)0; /*placeholder for label*/ 
54051     { 
54052       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54053       nextPC = 3 + MATCH_p; 
54054       
54055       #line 1433 "machine/pentium/disassembler.m"
54056       
54057 
54058               sprintf (str,  "FADD.R64", DIS_MEM64);
54059 
54060       
54061 
54062       
54063       
54064       
54065     } 
54066     goto MATCH_finished_a; 
54067     
54068   MATCH_label_a1052: (void)0; /*placeholder for label*/ 
54069     { 
54070       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54071       nextPC = 7 + MATCH_p; 
54072       
54073       #line 1433 "machine/pentium/disassembler.m"
54074       
54075 
54076               sprintf (str,  "FADD.R64", DIS_MEM64);
54077 
54078       
54079 
54080       
54081       
54082       
54083     } 
54084     goto MATCH_finished_a; 
54085     
54086   MATCH_label_a1053: (void)0; /*placeholder for label*/ 
54087     { 
54088       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54089       nextPC = 6 + MATCH_p; 
54090       
54091       #line 1433 "machine/pentium/disassembler.m"
54092       
54093 
54094               sprintf (str,  "FADD.R64", DIS_MEM64);
54095 
54096       
54097 
54098       
54099       
54100       
54101     } 
54102     goto MATCH_finished_a; 
54103     
54104   MATCH_label_a1054: (void)0; /*placeholder for label*/ 
54105     { 
54106       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54107       nextPC = 3 + MATCH_p; 
54108       
54109       #line 1627 "machine/pentium/disassembler.m"
54110       
54111 
54112               sprintf (str,  "FMUL.R64", DIS_MEM64);
54113 
54114       
54115 
54116       
54117       
54118       
54119     } 
54120     goto MATCH_finished_a; 
54121     
54122   MATCH_label_a1055: (void)0; /*placeholder for label*/ 
54123     { 
54124       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54125       nextPC = 7 + MATCH_p; 
54126       
54127       #line 1627 "machine/pentium/disassembler.m"
54128       
54129 
54130               sprintf (str,  "FMUL.R64", DIS_MEM64);
54131 
54132       
54133 
54134       
54135       
54136       
54137     } 
54138     goto MATCH_finished_a; 
54139     
54140   MATCH_label_a1056: (void)0; /*placeholder for label*/ 
54141     { 
54142       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54143       nextPC = 6 + MATCH_p; 
54144       
54145       #line 1627 "machine/pentium/disassembler.m"
54146       
54147 
54148               sprintf (str,  "FMUL.R64", DIS_MEM64);
54149 
54150       
54151 
54152       
54153       
54154       
54155     } 
54156     goto MATCH_finished_a; 
54157     
54158   MATCH_label_a1057: (void)0; /*placeholder for label*/ 
54159     { 
54160       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54161       nextPC = 3 + MATCH_p; 
54162       
54163       #line 1466 "machine/pentium/disassembler.m"
54164       
54165 
54166               sprintf (str,  "FCOM.R64", DIS_MEM64);
54167 
54168       
54169 
54170       
54171       
54172       
54173     } 
54174     goto MATCH_finished_a; 
54175     
54176   MATCH_label_a1058: (void)0; /*placeholder for label*/ 
54177     { 
54178       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54179       nextPC = 7 + MATCH_p; 
54180       
54181       #line 1466 "machine/pentium/disassembler.m"
54182       
54183 
54184               sprintf (str,  "FCOM.R64", DIS_MEM64);
54185 
54186       
54187 
54188       
54189       
54190       
54191     } 
54192     goto MATCH_finished_a; 
54193     
54194   MATCH_label_a1059: (void)0; /*placeholder for label*/ 
54195     { 
54196       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54197       nextPC = 6 + MATCH_p; 
54198       
54199       #line 1466 "machine/pentium/disassembler.m"
54200       
54201 
54202               sprintf (str,  "FCOM.R64", DIS_MEM64);
54203 
54204       
54205 
54206       
54207       
54208       
54209     } 
54210     goto MATCH_finished_a; 
54211     
54212   MATCH_label_a1060: (void)0; /*placeholder for label*/ 
54213     { 
54214       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54215       nextPC = 3 + MATCH_p; 
54216       
54217       #line 1478 "machine/pentium/disassembler.m"
54218       
54219 
54220               sprintf (str,  "FCOMP.R64", DIS_MEM64);
54221 
54222       
54223 
54224       
54225       
54226       
54227     } 
54228     goto MATCH_finished_a; 
54229     
54230   MATCH_label_a1061: (void)0; /*placeholder for label*/ 
54231     { 
54232       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54233       nextPC = 7 + MATCH_p; 
54234       
54235       #line 1478 "machine/pentium/disassembler.m"
54236       
54237 
54238               sprintf (str,  "FCOMP.R64", DIS_MEM64);
54239 
54240       
54241 
54242       
54243       
54244       
54245     } 
54246     goto MATCH_finished_a; 
54247     
54248   MATCH_label_a1062: (void)0; /*placeholder for label*/ 
54249     { 
54250       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54251       nextPC = 6 + MATCH_p; 
54252       
54253       #line 1478 "machine/pentium/disassembler.m"
54254       
54255 
54256               sprintf (str,  "FCOMP.R64", DIS_MEM64);
54257 
54258       
54259 
54260       
54261       
54262       
54263     } 
54264     goto MATCH_finished_a; 
54265     
54266   MATCH_label_a1063: (void)0; /*placeholder for label*/ 
54267     { 
54268       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54269       nextPC = 3 + MATCH_p; 
54270       
54271       #line 1717 "machine/pentium/disassembler.m"
54272       
54273 
54274               sprintf (str,  "FSUB.R64", DIS_MEM64);
54275 
54276       
54277 
54278       
54279       
54280       
54281     } 
54282     goto MATCH_finished_a; 
54283     
54284   MATCH_label_a1064: (void)0; /*placeholder for label*/ 
54285     { 
54286       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54287       nextPC = 7 + MATCH_p; 
54288       
54289       #line 1717 "machine/pentium/disassembler.m"
54290       
54291 
54292               sprintf (str,  "FSUB.R64", DIS_MEM64);
54293 
54294       
54295 
54296       
54297       
54298       
54299     } 
54300     goto MATCH_finished_a; 
54301     
54302   MATCH_label_a1065: (void)0; /*placeholder for label*/ 
54303     { 
54304       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54305       nextPC = 6 + MATCH_p; 
54306       
54307       #line 1717 "machine/pentium/disassembler.m"
54308       
54309 
54310               sprintf (str,  "FSUB.R64", DIS_MEM64);
54311 
54312       
54313 
54314       
54315       
54316       
54317     } 
54318     goto MATCH_finished_a; 
54319     
54320   MATCH_label_a1066: (void)0; /*placeholder for label*/ 
54321     { 
54322       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54323       nextPC = 3 + MATCH_p; 
54324       
54325       #line 1738 "machine/pentium/disassembler.m"
54326       
54327 
54328               sprintf (str,  "FSUBR.R64", DIS_MEM64);
54329 
54330       
54331 
54332       
54333       
54334       
54335     } 
54336     goto MATCH_finished_a; 
54337     
54338   MATCH_label_a1067: (void)0; /*placeholder for label*/ 
54339     { 
54340       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54341       nextPC = 7 + MATCH_p; 
54342       
54343       #line 1738 "machine/pentium/disassembler.m"
54344       
54345 
54346               sprintf (str,  "FSUBR.R64", DIS_MEM64);
54347 
54348       
54349 
54350       
54351       
54352       
54353     } 
54354     goto MATCH_finished_a; 
54355     
54356   MATCH_label_a1068: (void)0; /*placeholder for label*/ 
54357     { 
54358       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54359       nextPC = 6 + MATCH_p; 
54360       
54361       #line 1738 "machine/pentium/disassembler.m"
54362       
54363 
54364               sprintf (str,  "FSUBR.R64", DIS_MEM64);
54365 
54366       
54367 
54368       
54369       
54370       
54371     } 
54372     goto MATCH_finished_a; 
54373     
54374   MATCH_label_a1069: (void)0; /*placeholder for label*/ 
54375     { 
54376       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54377       nextPC = 3 + MATCH_p; 
54378       
54379       #line 1511 "machine/pentium/disassembler.m"
54380       
54381 
54382               sprintf (str,  "FDIV.R64", DIS_MEM64);
54383 
54384       
54385 
54386       
54387       
54388       
54389     } 
54390     goto MATCH_finished_a; 
54391     
54392   MATCH_label_a1070: (void)0; /*placeholder for label*/ 
54393     { 
54394       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54395       nextPC = 7 + MATCH_p; 
54396       
54397       #line 1511 "machine/pentium/disassembler.m"
54398       
54399 
54400               sprintf (str,  "FDIV.R64", DIS_MEM64);
54401 
54402       
54403 
54404       
54405       
54406       
54407     } 
54408     goto MATCH_finished_a; 
54409     
54410   MATCH_label_a1071: (void)0; /*placeholder for label*/ 
54411     { 
54412       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54413       nextPC = 6 + MATCH_p; 
54414       
54415       #line 1511 "machine/pentium/disassembler.m"
54416       
54417 
54418               sprintf (str,  "FDIV.R64", DIS_MEM64);
54419 
54420       
54421 
54422       
54423       
54424       
54425     } 
54426     goto MATCH_finished_a; 
54427     
54428   MATCH_label_a1072: (void)0; /*placeholder for label*/ 
54429     { 
54430       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54431       nextPC = 3 + MATCH_p; 
54432       
54433       #line 1532 "machine/pentium/disassembler.m"
54434       
54435 
54436               sprintf (str,  "FDIVR.R64", DIS_MEM64);
54437 
54438       
54439 
54440       
54441       
54442       
54443     } 
54444     goto MATCH_finished_a; 
54445     
54446   MATCH_label_a1073: (void)0; /*placeholder for label*/ 
54447     { 
54448       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54449       nextPC = 7 + MATCH_p; 
54450       
54451       #line 1532 "machine/pentium/disassembler.m"
54452       
54453 
54454               sprintf (str,  "FDIVR.R64", DIS_MEM64);
54455 
54456       
54457 
54458       
54459       
54460       
54461     } 
54462     goto MATCH_finished_a; 
54463     
54464   MATCH_label_a1074: (void)0; /*placeholder for label*/ 
54465     { 
54466       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54467       nextPC = 6 + MATCH_p; 
54468       
54469       #line 1532 "machine/pentium/disassembler.m"
54470       
54471 
54472               sprintf (str,  "FDIVR.R64", DIS_MEM64);
54473 
54474       
54475 
54476       
54477       
54478       
54479     } 
54480     goto MATCH_finished_a; 
54481     
54482   MATCH_label_a1075: (void)0; /*placeholder for label*/ 
54483     { 
54484       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54485       nextPC = 3 + MATCH_p; 
54486       
54487       #line 1583 "machine/pentium/disassembler.m"
54488       
54489 
54490               sprintf (str,  "FLD.lsR64", DIS_MEM64);
54491 
54492       
54493 
54494       
54495       
54496       
54497     } 
54498     goto MATCH_finished_a; 
54499     
54500   MATCH_label_a1076: (void)0; /*placeholder for label*/ 
54501     { 
54502       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54503       nextPC = 7 + MATCH_p; 
54504       
54505       #line 1583 "machine/pentium/disassembler.m"
54506       
54507 
54508               sprintf (str,  "FLD.lsR64", DIS_MEM64);
54509 
54510       
54511 
54512       
54513       
54514       
54515     } 
54516     goto MATCH_finished_a; 
54517     
54518   MATCH_label_a1077: (void)0; /*placeholder for label*/ 
54519     { 
54520       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54521       nextPC = 6 + MATCH_p; 
54522       
54523       #line 1583 "machine/pentium/disassembler.m"
54524       
54525 
54526               sprintf (str,  "FLD.lsR64", DIS_MEM64);
54527 
54528       
54529 
54530       
54531       
54532       
54533     } 
54534     goto MATCH_finished_a; 
54535     
54536   MATCH_label_a1078: (void)0; /*placeholder for label*/ 
54537     { 
54538       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54539       nextPC = 3 + MATCH_p; 
54540       
54541       #line 1684 "machine/pentium/disassembler.m"
54542       
54543 
54544               sprintf (str,  "FST.lsR64", DIS_MEM64);
54545 
54546       
54547 
54548       
54549       
54550       
54551     } 
54552     goto MATCH_finished_a; 
54553     
54554   MATCH_label_a1079: (void)0; /*placeholder for label*/ 
54555     { 
54556       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54557       nextPC = 7 + MATCH_p; 
54558       
54559       #line 1684 "machine/pentium/disassembler.m"
54560       
54561 
54562               sprintf (str,  "FST.lsR64", DIS_MEM64);
54563 
54564       
54565 
54566       
54567       
54568       
54569     } 
54570     goto MATCH_finished_a; 
54571     
54572   MATCH_label_a1080: (void)0; /*placeholder for label*/ 
54573     { 
54574       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54575       nextPC = 6 + MATCH_p; 
54576       
54577       #line 1684 "machine/pentium/disassembler.m"
54578       
54579 
54580               sprintf (str,  "FST.lsR64", DIS_MEM64);
54581 
54582       
54583 
54584       
54585       
54586       
54587     } 
54588     goto MATCH_finished_a; 
54589     
54590   MATCH_label_a1081: (void)0; /*placeholder for label*/ 
54591     { 
54592       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54593       nextPC = 3 + MATCH_p; 
54594       
54595       #line 1690 "machine/pentium/disassembler.m"
54596       
54597 
54598               sprintf (str,  "FSTP.lsR64", DIS_MEM64);
54599 
54600       
54601 
54602       
54603       
54604       
54605     } 
54606     goto MATCH_finished_a; 
54607     
54608   MATCH_label_a1082: (void)0; /*placeholder for label*/ 
54609     { 
54610       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54611       nextPC = 7 + MATCH_p; 
54612       
54613       #line 1690 "machine/pentium/disassembler.m"
54614       
54615 
54616               sprintf (str,  "FSTP.lsR64", DIS_MEM64);
54617 
54618       
54619 
54620       
54621       
54622       
54623     } 
54624     goto MATCH_finished_a; 
54625     
54626   MATCH_label_a1083: (void)0; /*placeholder for label*/ 
54627     { 
54628       unsigned Mem64 = 1 + addressToPC(MATCH_p);
54629       nextPC = 6 + MATCH_p; 
54630       
54631       #line 1690 "machine/pentium/disassembler.m"
54632       
54633 
54634               sprintf (str,  "FSTP.lsR64", DIS_MEM64);
54635 
54636       
54637 
54638       
54639       
54640       
54641     } 
54642     goto MATCH_finished_a; 
54643     
54644   MATCH_label_a1084: (void)0; /*placeholder for label*/ 
54645     { 
54646       unsigned Mem = 1 + addressToPC(MATCH_p);
54647       nextPC = 3 + MATCH_p; 
54648       
54649       #line 1663 "machine/pentium/disassembler.m"
54650       
54651 
54652               sprintf (str,  "FRSTOR", DIS_MEM);
54653 
54654       
54655 
54656       
54657       
54658       
54659     } 
54660     goto MATCH_finished_a; 
54661     
54662   MATCH_label_a1085: (void)0; /*placeholder for label*/ 
54663     { 
54664       unsigned Mem = 1 + addressToPC(MATCH_p);
54665       nextPC = 7 + MATCH_p; 
54666       
54667       #line 1663 "machine/pentium/disassembler.m"
54668       
54669 
54670               sprintf (str,  "FRSTOR", DIS_MEM);
54671 
54672       
54673 
54674       
54675       
54676       
54677     } 
54678     goto MATCH_finished_a; 
54679     
54680   MATCH_label_a1086: (void)0; /*placeholder for label*/ 
54681     { 
54682       unsigned Mem = 1 + addressToPC(MATCH_p);
54683       nextPC = 6 + MATCH_p; 
54684       
54685       #line 1663 "machine/pentium/disassembler.m"
54686       
54687 
54688               sprintf (str,  "FRSTOR", DIS_MEM);
54689 
54690       
54691 
54692       
54693       
54694       
54695     } 
54696     goto MATCH_finished_a; 
54697     
54698   MATCH_label_a1087: (void)0; /*placeholder for label*/ 
54699     { 
54700       unsigned Mem = 1 + addressToPC(MATCH_p);
54701       nextPC = 3 + MATCH_p; 
54702       
54703       #line 1666 "machine/pentium/disassembler.m"
54704       
54705 
54706               sprintf (str,  "FNSAVE", DIS_MEM);
54707 
54708       
54709 
54710       
54711       
54712       
54713     } 
54714     goto MATCH_finished_a; 
54715     
54716   MATCH_label_a1088: (void)0; /*placeholder for label*/ 
54717     { 
54718       unsigned Mem = 1 + addressToPC(MATCH_p);
54719       nextPC = 7 + MATCH_p; 
54720       
54721       #line 1666 "machine/pentium/disassembler.m"
54722       
54723 
54724               sprintf (str,  "FNSAVE", DIS_MEM);
54725 
54726       
54727 
54728       
54729       
54730       
54731     } 
54732     goto MATCH_finished_a; 
54733     
54734   MATCH_label_a1089: (void)0; /*placeholder for label*/ 
54735     { 
54736       unsigned Mem = 1 + addressToPC(MATCH_p);
54737       nextPC = 6 + MATCH_p; 
54738       
54739       #line 1666 "machine/pentium/disassembler.m"
54740       
54741 
54742               sprintf (str,  "FNSAVE", DIS_MEM);
54743 
54744       
54745 
54746       
54747       
54748       
54749     } 
54750     goto MATCH_finished_a; 
54751     
54752   MATCH_label_a1090: (void)0; /*placeholder for label*/ 
54753     { 
54754       unsigned Mem16 = 1 + addressToPC(MATCH_p);
54755       nextPC = 3 + MATCH_p; 
54756       
54757       #line 1708 "machine/pentium/disassembler.m"
54758       
54759 
54760               sprintf (str,  "FSTSW", DIS_MEM16);
54761 
54762       
54763 
54764       
54765       
54766       
54767     } 
54768     goto MATCH_finished_a; 
54769     
54770   MATCH_label_a1091: (void)0; /*placeholder for label*/ 
54771     { 
54772       unsigned Mem16 = 1 + addressToPC(MATCH_p);
54773       nextPC = 7 + MATCH_p; 
54774       
54775       #line 1708 "machine/pentium/disassembler.m"
54776       
54777 
54778               sprintf (str,  "FSTSW", DIS_MEM16);
54779 
54780       
54781 
54782       
54783       
54784       
54785     } 
54786     goto MATCH_finished_a; 
54787     
54788   MATCH_label_a1092: (void)0; /*placeholder for label*/ 
54789     { 
54790       unsigned Mem16 = 1 + addressToPC(MATCH_p);
54791       nextPC = 6 + MATCH_p; 
54792       
54793       #line 1708 "machine/pentium/disassembler.m"
54794       
54795 
54796               sprintf (str,  "FSTSW", DIS_MEM16);
54797 
54798       
54799 
54800       
54801       
54802       
54803     } 
54804     goto MATCH_finished_a; 
54805     
54806   MATCH_label_a1093: (void)0; /*placeholder for label*/ 
54807     { 
54808       unsigned Mem16 = 1 + addressToPC(MATCH_p);
54809       nextPC = 3 + MATCH_p; 
54810       
54811       #line 1448 "machine/pentium/disassembler.m"
54812       
54813 
54814               sprintf (str,  "FIADD.I16", DIS_MEM16);
54815 
54816       
54817 
54818       
54819       
54820       
54821     } 
54822     goto MATCH_finished_a; 
54823     
54824   MATCH_label_a1094: (void)0; /*placeholder for label*/ 
54825     { 
54826       unsigned Mem16 = 1 + addressToPC(MATCH_p);
54827       nextPC = 7 + MATCH_p; 
54828       
54829       #line 1448 "machine/pentium/disassembler.m"
54830       
54831 
54832               sprintf (str,  "FIADD.I16", DIS_MEM16);
54833 
54834       
54835 
54836       
54837       
54838       
54839     } 
54840     goto MATCH_finished_a; 
54841     
54842   MATCH_label_a1095: (void)0; /*placeholder for label*/ 
54843     { 
54844       unsigned Mem16 = 1 + addressToPC(MATCH_p);
54845       nextPC = 6 + MATCH_p; 
54846       
54847       #line 1448 "machine/pentium/disassembler.m"
54848       
54849 
54850               sprintf (str,  "FIADD.I16", DIS_MEM16);
54851 
54852       
54853 
54854       
54855       
54856       
54857     } 
54858     goto MATCH_finished_a; 
54859     
54860   MATCH_label_a1096: (void)0; /*placeholder for label*/ 
54861     { 
54862       unsigned Mem16 = 1 + addressToPC(MATCH_p);
54863       nextPC = 3 + MATCH_p; 
54864       
54865       #line 1642 "machine/pentium/disassembler.m"
54866       
54867 
54868               sprintf (str,  "FIMUL.I16", DIS_MEM16);
54869 
54870       
54871 
54872       
54873       
54874       
54875     } 
54876     goto MATCH_finished_a; 
54877     
54878   MATCH_label_a1097: (void)0; /*placeholder for label*/ 
54879     { 
54880       unsigned Mem16 = 1 + addressToPC(MATCH_p);
54881       nextPC = 7 + MATCH_p; 
54882       
54883       #line 1642 "machine/pentium/disassembler.m"
54884       
54885 
54886               sprintf (str,  "FIMUL.I16", DIS_MEM16);
54887 
54888       
54889 
54890       
54891       
54892       
54893     } 
54894     goto MATCH_finished_a; 
54895     
54896   MATCH_label_a1098: (void)0; /*placeholder for label*/ 
54897     { 
54898       unsigned Mem16 = 1 + addressToPC(MATCH_p);
54899       nextPC = 6 + MATCH_p; 
54900       
54901       #line 1642 "machine/pentium/disassembler.m"
54902       
54903 
54904               sprintf (str,  "FIMUL.I16", DIS_MEM16);
54905 
54906       
54907 
54908       
54909       
54910       
54911     } 
54912     goto MATCH_finished_a; 
54913     
54914   MATCH_label_a1099: (void)0; /*placeholder for label*/ 
54915     { 
54916       unsigned Mem16 = 1 + addressToPC(MATCH_p);
54917       nextPC = 3 + MATCH_p; 
54918       
54919       #line 1472 "machine/pentium/disassembler.m"
54920       
54921 
54922               sprintf (str,  "FICOM.I16", DIS_MEM16);
54923 
54924       
54925 
54926       
54927       
54928       
54929     } 
54930     goto MATCH_finished_a; 
54931     
54932   MATCH_label_a1100: (void)0; /*placeholder for label*/ 
54933     { 
54934       unsigned Mem16 = 1 + addressToPC(MATCH_p);
54935       nextPC = 7 + MATCH_p; 
54936       
54937       #line 1472 "machine/pentium/disassembler.m"
54938       
54939 
54940               sprintf (str,  "FICOM.I16", DIS_MEM16);
54941 
54942       
54943 
54944       
54945       
54946       
54947     } 
54948     goto MATCH_finished_a; 
54949     
54950   MATCH_label_a1101: (void)0; /*placeholder for label*/ 
54951     { 
54952       unsigned Mem16 = 1 + addressToPC(MATCH_p);
54953       nextPC = 6 + MATCH_p; 
54954       
54955       #line 1472 "machine/pentium/disassembler.m"
54956       
54957 
54958               sprintf (str,  "FICOM.I16", DIS_MEM16);
54959 
54960       
54961 
54962       
54963       
54964       
54965     } 
54966     goto MATCH_finished_a; 
54967     
54968   MATCH_label_a1102: (void)0; /*placeholder for label*/ 
54969     { 
54970       unsigned Mem16 = 1 + addressToPC(MATCH_p);
54971       nextPC = 3 + MATCH_p; 
54972       
54973       #line 1490 "machine/pentium/disassembler.m"
54974       
54975 
54976               sprintf (str,  "FICOMP.I16", DIS_MEM16);
54977 
54978       
54979 
54980       
54981       
54982       
54983     } 
54984     goto MATCH_finished_a; 
54985     
54986   MATCH_label_a1103: (void)0; /*placeholder for label*/ 
54987     { 
54988       unsigned Mem16 = 1 + addressToPC(MATCH_p);
54989       nextPC = 7 + MATCH_p; 
54990       
54991       #line 1490 "machine/pentium/disassembler.m"
54992       
54993 
54994               sprintf (str,  "FICOMP.I16", DIS_MEM16);
54995 
54996       
54997 
54998       
54999       
55000       
55001     } 
55002     goto MATCH_finished_a; 
55003     
55004   MATCH_label_a1104: (void)0; /*placeholder for label*/ 
55005     { 
55006       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55007       nextPC = 6 + MATCH_p; 
55008       
55009       #line 1490 "machine/pentium/disassembler.m"
55010       
55011 
55012               sprintf (str,  "FICOMP.I16", DIS_MEM16);
55013 
55014       
55015 
55016       
55017       
55018       
55019     } 
55020     goto MATCH_finished_a; 
55021     
55022   MATCH_label_a1105: (void)0; /*placeholder for label*/ 
55023     { 
55024       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55025       nextPC = 3 + MATCH_p; 
55026       
55027       #line 1729 "machine/pentium/disassembler.m"
55028       
55029 
55030               sprintf (str,  "FISUB.I16", DIS_MEM16);
55031 
55032       
55033 
55034       
55035       
55036       
55037     } 
55038     goto MATCH_finished_a; 
55039     
55040   MATCH_label_a1106: (void)0; /*placeholder for label*/ 
55041     { 
55042       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55043       nextPC = 7 + MATCH_p; 
55044       
55045       #line 1729 "machine/pentium/disassembler.m"
55046       
55047 
55048               sprintf (str,  "FISUB.I16", DIS_MEM16);
55049 
55050       
55051 
55052       
55053       
55054       
55055     } 
55056     goto MATCH_finished_a; 
55057     
55058   MATCH_label_a1107: (void)0; /*placeholder for label*/ 
55059     { 
55060       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55061       nextPC = 6 + MATCH_p; 
55062       
55063       #line 1729 "machine/pentium/disassembler.m"
55064       
55065 
55066               sprintf (str,  "FISUB.I16", DIS_MEM16);
55067 
55068       
55069 
55070       
55071       
55072       
55073     } 
55074     goto MATCH_finished_a; 
55075     
55076   MATCH_label_a1108: (void)0; /*placeholder for label*/ 
55077     { 
55078       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55079       nextPC = 3 + MATCH_p; 
55080       
55081       #line 1750 "machine/pentium/disassembler.m"
55082       
55083 
55084               sprintf (str,  "FISUBR.I16", DIS_MEM16);
55085 
55086       
55087 
55088       
55089       
55090       
55091     } 
55092     goto MATCH_finished_a; 
55093     
55094   MATCH_label_a1109: (void)0; /*placeholder for label*/ 
55095     { 
55096       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55097       nextPC = 7 + MATCH_p; 
55098       
55099       #line 1750 "machine/pentium/disassembler.m"
55100       
55101 
55102               sprintf (str,  "FISUBR.I16", DIS_MEM16);
55103 
55104       
55105 
55106       
55107       
55108       
55109     } 
55110     goto MATCH_finished_a; 
55111     
55112   MATCH_label_a1110: (void)0; /*placeholder for label*/ 
55113     { 
55114       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55115       nextPC = 6 + MATCH_p; 
55116       
55117       #line 1750 "machine/pentium/disassembler.m"
55118       
55119 
55120               sprintf (str,  "FISUBR.I16", DIS_MEM16);
55121 
55122       
55123 
55124       
55125       
55126       
55127     } 
55128     goto MATCH_finished_a; 
55129     
55130   MATCH_label_a1111: (void)0; /*placeholder for label*/ 
55131     { 
55132       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55133       nextPC = 3 + MATCH_p; 
55134       
55135       #line 1526 "machine/pentium/disassembler.m"
55136       
55137 
55138               sprintf (str,  "FIDIV.I16", DIS_MEM16);
55139 
55140       
55141 
55142       
55143       
55144       
55145     } 
55146     goto MATCH_finished_a; 
55147     
55148   MATCH_label_a1112: (void)0; /*placeholder for label*/ 
55149     { 
55150       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55151       nextPC = 7 + MATCH_p; 
55152       
55153       #line 1526 "machine/pentium/disassembler.m"
55154       
55155 
55156               sprintf (str,  "FIDIV.I16", DIS_MEM16);
55157 
55158       
55159 
55160       
55161       
55162       
55163     } 
55164     goto MATCH_finished_a; 
55165     
55166   MATCH_label_a1113: (void)0; /*placeholder for label*/ 
55167     { 
55168       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55169       nextPC = 6 + MATCH_p; 
55170       
55171       #line 1526 "machine/pentium/disassembler.m"
55172       
55173 
55174               sprintf (str,  "FIDIV.I16", DIS_MEM16);
55175 
55176       
55177 
55178       
55179       
55180       
55181     } 
55182     goto MATCH_finished_a; 
55183     
55184   MATCH_label_a1114: (void)0; /*placeholder for label*/ 
55185     { 
55186       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55187       nextPC = 3 + MATCH_p; 
55188       
55189       #line 1544 "machine/pentium/disassembler.m"
55190       
55191 
55192               sprintf (str,  "FIDIVR.I16", DIS_MEM16);
55193 
55194       
55195 
55196       
55197       
55198       
55199     } 
55200     goto MATCH_finished_a; 
55201     
55202   MATCH_label_a1115: (void)0; /*placeholder for label*/ 
55203     { 
55204       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55205       nextPC = 7 + MATCH_p; 
55206       
55207       #line 1544 "machine/pentium/disassembler.m"
55208       
55209 
55210               sprintf (str,  "FIDIVR.I16", DIS_MEM16);
55211 
55212       
55213 
55214       
55215       
55216       
55217     } 
55218     goto MATCH_finished_a; 
55219     
55220   MATCH_label_a1116: (void)0; /*placeholder for label*/ 
55221     { 
55222       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55223       nextPC = 6 + MATCH_p; 
55224       
55225       #line 1544 "machine/pentium/disassembler.m"
55226       
55227 
55228               sprintf (str,  "FIDIVR.I16", DIS_MEM16);
55229 
55230       
55231 
55232       
55233       
55234       
55235     } 
55236     goto MATCH_finished_a; 
55237     
55238   MATCH_label_a1117: (void)0; /*placeholder for label*/ 
55239     { 
55240       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55241       nextPC = 3 + MATCH_p; 
55242       
55243       #line 1553 "machine/pentium/disassembler.m"
55244       
55245 
55246               sprintf (str,  "FILD.lsI16", DIS_MEM16);
55247 
55248       
55249 
55250       
55251       
55252       
55253     } 
55254     goto MATCH_finished_a; 
55255     
55256   MATCH_label_a1118: (void)0; /*placeholder for label*/ 
55257     { 
55258       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55259       nextPC = 7 + MATCH_p; 
55260       
55261       #line 1553 "machine/pentium/disassembler.m"
55262       
55263 
55264               sprintf (str,  "FILD.lsI16", DIS_MEM16);
55265 
55266       
55267 
55268       
55269       
55270       
55271     } 
55272     goto MATCH_finished_a; 
55273     
55274   MATCH_label_a1119: (void)0; /*placeholder for label*/ 
55275     { 
55276       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55277       nextPC = 6 + MATCH_p; 
55278       
55279       #line 1553 "machine/pentium/disassembler.m"
55280       
55281 
55282               sprintf (str,  "FILD.lsI16", DIS_MEM16);
55283 
55284       
55285 
55286       
55287       
55288       
55289     } 
55290     goto MATCH_finished_a; 
55291     
55292   MATCH_label_a1120: (void)0; /*placeholder for label*/ 
55293     { 
55294       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55295       nextPC = 3 + MATCH_p; 
55296       
55297       #line 1565 "machine/pentium/disassembler.m"
55298       
55299 
55300               sprintf (str,  "FIST.lsI16", DIS_MEM16);
55301 
55302       
55303 
55304       
55305       
55306       
55307     } 
55308     goto MATCH_finished_a; 
55309     
55310   MATCH_label_a1121: (void)0; /*placeholder for label*/ 
55311     { 
55312       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55313       nextPC = 7 + MATCH_p; 
55314       
55315       #line 1565 "machine/pentium/disassembler.m"
55316       
55317 
55318               sprintf (str,  "FIST.lsI16", DIS_MEM16);
55319 
55320       
55321 
55322       
55323       
55324       
55325     } 
55326     goto MATCH_finished_a; 
55327     
55328   MATCH_label_a1122: (void)0; /*placeholder for label*/ 
55329     { 
55330       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55331       nextPC = 6 + MATCH_p; 
55332       
55333       #line 1565 "machine/pentium/disassembler.m"
55334       
55335 
55336               sprintf (str,  "FIST.lsI16", DIS_MEM16);
55337 
55338       
55339 
55340       
55341       
55342       
55343     } 
55344     goto MATCH_finished_a; 
55345     
55346   MATCH_label_a1123: (void)0; /*placeholder for label*/ 
55347     { 
55348       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55349       nextPC = 3 + MATCH_p; 
55350       
55351       #line 1571 "machine/pentium/disassembler.m"
55352       
55353 
55354               sprintf (str,  "FISTP.lsI16", DIS_MEM16);
55355 
55356       
55357 
55358       
55359       
55360       
55361     } 
55362     goto MATCH_finished_a; 
55363     
55364   MATCH_label_a1124: (void)0; /*placeholder for label*/ 
55365     { 
55366       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55367       nextPC = 7 + MATCH_p; 
55368       
55369       #line 1571 "machine/pentium/disassembler.m"
55370       
55371 
55372               sprintf (str,  "FISTP.lsI16", DIS_MEM16);
55373 
55374       
55375 
55376       
55377       
55378       
55379     } 
55380     goto MATCH_finished_a; 
55381     
55382   MATCH_label_a1125: (void)0; /*placeholder for label*/ 
55383     { 
55384       unsigned Mem16 = 1 + addressToPC(MATCH_p);
55385       nextPC = 6 + MATCH_p; 
55386       
55387       #line 1571 "machine/pentium/disassembler.m"
55388       
55389 
55390               sprintf (str,  "FISTP.lsI16", DIS_MEM16);
55391 
55392       
55393 
55394       
55395       
55396       
55397     } 
55398     goto MATCH_finished_a; 
55399     
55400   MATCH_label_a1126: (void)0; /*placeholder for label*/ 
55401     { 
55402       unsigned Mem80 = 1 + addressToPC(MATCH_p);
55403       nextPC = 3 + MATCH_p; 
55404       
55405       #line 1451 "machine/pentium/disassembler.m"
55406       
55407 
55408               sprintf (str,  "FBLD", DIS_MEM80);
55409 
55410       
55411 
55412       
55413       
55414       
55415     } 
55416     goto MATCH_finished_a; 
55417     
55418   MATCH_label_a1127: (void)0; /*placeholder for label*/ 
55419     { 
55420       unsigned Mem80 = 1 + addressToPC(MATCH_p);
55421       nextPC = 7 + MATCH_p; 
55422       
55423       #line 1451 "machine/pentium/disassembler.m"
55424       
55425 
55426               sprintf (str,  "FBLD", DIS_MEM80);
55427 
55428       
55429 
55430       
55431       
55432       
55433     } 
55434     goto MATCH_finished_a; 
55435     
55436   MATCH_label_a1128: (void)0; /*placeholder for label*/ 
55437     { 
55438       unsigned Mem80 = 1 + addressToPC(MATCH_p);
55439       nextPC = 6 + MATCH_p; 
55440       
55441       #line 1451 "machine/pentium/disassembler.m"
55442       
55443 
55444               sprintf (str,  "FBLD", DIS_MEM80);
55445 
55446       
55447 
55448       
55449       
55450       
55451     } 
55452     goto MATCH_finished_a; 
55453     
55454   MATCH_label_a1129: (void)0; /*placeholder for label*/ 
55455     { 
55456       unsigned Mem64 = 1 + addressToPC(MATCH_p);
55457       nextPC = 3 + MATCH_p; 
55458       
55459       #line 1559 "machine/pentium/disassembler.m"
55460       
55461 
55462               sprintf (str,  "FILD64", DIS_MEM64);
55463 
55464       
55465 
55466       
55467       
55468       
55469     } 
55470     goto MATCH_finished_a; 
55471     
55472   MATCH_label_a1130: (void)0; /*placeholder for label*/ 
55473     { 
55474       unsigned Mem64 = 1 + addressToPC(MATCH_p);
55475       nextPC = 7 + MATCH_p; 
55476       
55477       #line 1559 "machine/pentium/disassembler.m"
55478       
55479 
55480               sprintf (str,  "FILD64", DIS_MEM64);
55481 
55482       
55483 
55484       
55485       
55486       
55487     } 
55488     goto MATCH_finished_a; 
55489     
55490   MATCH_label_a1131: (void)0; /*placeholder for label*/ 
55491     { 
55492       unsigned Mem64 = 1 + addressToPC(MATCH_p);
55493       nextPC = 6 + MATCH_p; 
55494       
55495       #line 1559 "machine/pentium/disassembler.m"
55496       
55497 
55498               sprintf (str,  "FILD64", DIS_MEM64);
55499 
55500       
55501 
55502       
55503       
55504       
55505     } 
55506     goto MATCH_finished_a; 
55507     
55508   MATCH_label_a1132: (void)0; /*placeholder for label*/ 
55509     { 
55510       unsigned Mem80 = 1 + addressToPC(MATCH_p);
55511       nextPC = 3 + MATCH_p; 
55512       
55513       #line 1454 "machine/pentium/disassembler.m"
55514       
55515 
55516               sprintf (str,  "FBSTP", DIS_MEM80);
55517 
55518       
55519 
55520       
55521       
55522       
55523     } 
55524     goto MATCH_finished_a; 
55525     
55526   MATCH_label_a1133: (void)0; /*placeholder for label*/ 
55527     { 
55528       unsigned Mem80 = 1 + addressToPC(MATCH_p);
55529       nextPC = 7 + MATCH_p; 
55530       
55531       #line 1454 "machine/pentium/disassembler.m"
55532       
55533 
55534               sprintf (str,  "FBSTP", DIS_MEM80);
55535 
55536       
55537 
55538       
55539       
55540       
55541     } 
55542     goto MATCH_finished_a; 
55543     
55544   MATCH_label_a1134: (void)0; /*placeholder for label*/ 
55545     { 
55546       unsigned Mem80 = 1 + addressToPC(MATCH_p);
55547       nextPC = 6 + MATCH_p; 
55548       
55549       #line 1454 "machine/pentium/disassembler.m"
55550       
55551 
55552               sprintf (str,  "FBSTP", DIS_MEM80);
55553 
55554       
55555 
55556       
55557       
55558       
55559     } 
55560     goto MATCH_finished_a; 
55561     
55562   MATCH_label_a1135: (void)0; /*placeholder for label*/ 
55563     { 
55564       unsigned Mem64 = 1 + addressToPC(MATCH_p);
55565       nextPC = 3 + MATCH_p; 
55566       
55567       #line 1577 "machine/pentium/disassembler.m"
55568       
55569 
55570               sprintf (str,  "FISTP64", DIS_MEM64);
55571 
55572       
55573 
55574       
55575       
55576       
55577     } 
55578     goto MATCH_finished_a; 
55579     
55580   MATCH_label_a1136: (void)0; /*placeholder for label*/ 
55581     { 
55582       unsigned Mem64 = 1 + addressToPC(MATCH_p);
55583       nextPC = 7 + MATCH_p; 
55584       
55585       #line 1577 "machine/pentium/disassembler.m"
55586       
55587 
55588               sprintf (str,  "FISTP64", DIS_MEM64);
55589 
55590       
55591 
55592       
55593       
55594       
55595     } 
55596     goto MATCH_finished_a; 
55597     
55598   MATCH_label_a1137: (void)0; /*placeholder for label*/ 
55599     { 
55600       unsigned Mem64 = 1 + addressToPC(MATCH_p);
55601       nextPC = 6 + MATCH_p; 
55602       
55603       #line 1577 "machine/pentium/disassembler.m"
55604       
55605 
55606               sprintf (str,  "FISTP64", DIS_MEM64);
55607 
55608       
55609 
55610       
55611       
55612       
55613     } 
55614     goto MATCH_finished_a; 
55615     
55616   MATCH_label_a1138: (void)0; /*placeholder for label*/ 
55617     { 
55618       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55619       unsigned i8 = (MATCH_w_8_16 & 0xff) /* i8 at 16 */;
55620       nextPC = 3 + MATCH_p; 
55621       
55622       #line 110 "machine/pentium/disassembler.m"
55623       
55624 
55625               sprintf (str,  "TEST.Eb.Ib", DIS_EADDR8, DIS_I8);
55626 
55627       
55628 
55629       
55630       
55631       
55632     } 
55633     goto MATCH_finished_a; 
55634     
55635   MATCH_label_a1139: (void)0; /*placeholder for label*/ 
55636     { 
55637       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55638       unsigned i8 = (MATCH_w_8_24 & 0xff) /* i8 at 24 */;
55639       nextPC = 4 + MATCH_p; 
55640       
55641       #line 110 "machine/pentium/disassembler.m"
55642       
55643 
55644               sprintf (str,  "TEST.Eb.Ib", DIS_EADDR8, DIS_I8);
55645 
55646       
55647 
55648       
55649       
55650       
55651     } 
55652     goto MATCH_finished_a; 
55653     
55654   MATCH_label_a1140: (void)0; /*placeholder for label*/ 
55655     { 
55656       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55657       unsigned i8 = (MATCH_w_8_56 & 0xff) /* i8 at 56 */;
55658       nextPC = 8 + MATCH_p; 
55659       
55660       #line 110 "machine/pentium/disassembler.m"
55661       
55662 
55663               sprintf (str,  "TEST.Eb.Ib", DIS_EADDR8, DIS_I8);
55664 
55665       
55666 
55667       
55668       
55669       
55670     } 
55671     goto MATCH_finished_a; 
55672     
55673   MATCH_label_a1141: (void)0; /*placeholder for label*/ 
55674     { 
55675       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55676       unsigned i8 = (MATCH_w_8_48 & 0xff) /* i8 at 48 */;
55677       nextPC = 7 + MATCH_p; 
55678       
55679       #line 110 "machine/pentium/disassembler.m"
55680       
55681 
55682               sprintf (str,  "TEST.Eb.Ib", DIS_EADDR8, DIS_I8);
55683 
55684       
55685 
55686       
55687       
55688       
55689     } 
55690     goto MATCH_finished_a; 
55691     
55692   MATCH_label_a1142: (void)0; /*placeholder for label*/ 
55693     { 
55694       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55695       nextPC = 2 + MATCH_p; 
55696       
55697       #line 621 "machine/pentium/disassembler.m"
55698       
55699 
55700               sprintf (str,  "NOTb", DIS_EADDR8);
55701 
55702       
55703 
55704       
55705       
55706       
55707     } 
55708     goto MATCH_finished_a; 
55709     
55710   MATCH_label_a1143: (void)0; /*placeholder for label*/ 
55711     { 
55712       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55713       nextPC = 3 + MATCH_p; 
55714       
55715       #line 621 "machine/pentium/disassembler.m"
55716       
55717 
55718               sprintf (str,  "NOTb", DIS_EADDR8);
55719 
55720       
55721 
55722       
55723       
55724       
55725     } 
55726     goto MATCH_finished_a; 
55727     
55728   MATCH_label_a1144: (void)0; /*placeholder for label*/ 
55729     { 
55730       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55731       nextPC = 7 + MATCH_p; 
55732       
55733       #line 621 "machine/pentium/disassembler.m"
55734       
55735 
55736               sprintf (str,  "NOTb", DIS_EADDR8);
55737 
55738       
55739 
55740       
55741       
55742       
55743     } 
55744     goto MATCH_finished_a; 
55745     
55746   MATCH_label_a1145: (void)0; /*placeholder for label*/ 
55747     { 
55748       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55749       nextPC = 6 + MATCH_p; 
55750       
55751       #line 621 "machine/pentium/disassembler.m"
55752       
55753 
55754               sprintf (str,  "NOTb", DIS_EADDR8);
55755 
55756       
55757 
55758       
55759       
55760       
55761     } 
55762     goto MATCH_finished_a; 
55763     
55764   MATCH_label_a1146: (void)0; /*placeholder for label*/ 
55765     { 
55766       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55767       nextPC = 2 + MATCH_p; 
55768       
55769       #line 630 "machine/pentium/disassembler.m"
55770       
55771 
55772               sprintf (str,  "NEGb", DIS_EADDR8);
55773 
55774       
55775 
55776       
55777       
55778       
55779     } 
55780     goto MATCH_finished_a; 
55781     
55782   MATCH_label_a1147: (void)0; /*placeholder for label*/ 
55783     { 
55784       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55785       nextPC = 3 + MATCH_p; 
55786       
55787       #line 630 "machine/pentium/disassembler.m"
55788       
55789 
55790               sprintf (str,  "NEGb", DIS_EADDR8);
55791 
55792       
55793 
55794       
55795       
55796       
55797     } 
55798     goto MATCH_finished_a; 
55799     
55800   MATCH_label_a1148: (void)0; /*placeholder for label*/ 
55801     { 
55802       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55803       nextPC = 7 + MATCH_p; 
55804       
55805       #line 630 "machine/pentium/disassembler.m"
55806       
55807 
55808               sprintf (str,  "NEGb", DIS_EADDR8);
55809 
55810       
55811 
55812       
55813       
55814       
55815     } 
55816     goto MATCH_finished_a; 
55817     
55818   MATCH_label_a1149: (void)0; /*placeholder for label*/ 
55819     { 
55820       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55821       nextPC = 6 + MATCH_p; 
55822       
55823       #line 630 "machine/pentium/disassembler.m"
55824       
55825 
55826               sprintf (str,  "NEGb", DIS_EADDR8);
55827 
55828       
55829 
55830       
55831       
55832       
55833     } 
55834     goto MATCH_finished_a; 
55835     
55836   MATCH_label_a1150: (void)0; /*placeholder for label*/ 
55837     { 
55838       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55839       nextPC = 2 + MATCH_p; 
55840       
55841       #line 639 "machine/pentium/disassembler.m"
55842       
55843 
55844               sprintf (str,  "MUL.AL", DIS_EADDR8);
55845 
55846       
55847 
55848       
55849       
55850       
55851     } 
55852     goto MATCH_finished_a; 
55853     
55854   MATCH_label_a1151: (void)0; /*placeholder for label*/ 
55855     { 
55856       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55857       nextPC = 3 + MATCH_p; 
55858       
55859       #line 639 "machine/pentium/disassembler.m"
55860       
55861 
55862               sprintf (str,  "MUL.AL", DIS_EADDR8);
55863 
55864       
55865 
55866       
55867       
55868       
55869     } 
55870     goto MATCH_finished_a; 
55871     
55872   MATCH_label_a1152: (void)0; /*placeholder for label*/ 
55873     { 
55874       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55875       nextPC = 7 + MATCH_p; 
55876       
55877       #line 639 "machine/pentium/disassembler.m"
55878       
55879 
55880               sprintf (str,  "MUL.AL", DIS_EADDR8);
55881 
55882       
55883 
55884       
55885       
55886       
55887     } 
55888     goto MATCH_finished_a; 
55889     
55890   MATCH_label_a1153: (void)0; /*placeholder for label*/ 
55891     { 
55892       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55893       nextPC = 6 + MATCH_p; 
55894       
55895       #line 639 "machine/pentium/disassembler.m"
55896       
55897 
55898               sprintf (str,  "MUL.AL", DIS_EADDR8);
55899 
55900       
55901 
55902       
55903       
55904       
55905     } 
55906     goto MATCH_finished_a; 
55907     
55908   MATCH_label_a1154: (void)0; /*placeholder for label*/ 
55909     { 
55910       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55911       nextPC = 2 + MATCH_p; 
55912       
55913       #line 881 "machine/pentium/disassembler.m"
55914       
55915 
55916               sprintf (str,  "IMULb", DIS_EADDR8);
55917 
55918       
55919 
55920       
55921       
55922       
55923     } 
55924     goto MATCH_finished_a; 
55925     
55926   MATCH_label_a1155: (void)0; /*placeholder for label*/ 
55927     { 
55928       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55929       nextPC = 3 + MATCH_p; 
55930       
55931       #line 881 "machine/pentium/disassembler.m"
55932       
55933 
55934               sprintf (str,  "IMULb", DIS_EADDR8);
55935 
55936       
55937 
55938       
55939       
55940       
55941     } 
55942     goto MATCH_finished_a; 
55943     
55944   MATCH_label_a1156: (void)0; /*placeholder for label*/ 
55945     { 
55946       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55947       nextPC = 7 + MATCH_p; 
55948       
55949       #line 881 "machine/pentium/disassembler.m"
55950       
55951 
55952               sprintf (str,  "IMULb", DIS_EADDR8);
55953 
55954       
55955 
55956       
55957       
55958       
55959     } 
55960     goto MATCH_finished_a; 
55961     
55962   MATCH_label_a1157: (void)0; /*placeholder for label*/ 
55963     { 
55964       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55965       nextPC = 6 + MATCH_p; 
55966       
55967       #line 881 "machine/pentium/disassembler.m"
55968       
55969 
55970               sprintf (str,  "IMULb", DIS_EADDR8);
55971 
55972       
55973 
55974       
55975       
55976       
55977     } 
55978     goto MATCH_finished_a; 
55979     
55980   MATCH_label_a1158: (void)0; /*placeholder for label*/ 
55981     { 
55982       unsigned Eaddr = 1 + addressToPC(MATCH_p);
55983       nextPC = 2 + MATCH_p; 
55984       
55985       #line 905 "machine/pentium/disassembler.m"
55986       
55987 
55988               sprintf (str,  "DIVAL", DIS_EADDR8);
55989 
55990       
55991 
55992       
55993       
55994       
55995     } 
55996     goto MATCH_finished_a; 
55997     
55998   MATCH_label_a1159: (void)0; /*placeholder for label*/ 
55999     { 
56000       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56001       nextPC = 3 + MATCH_p; 
56002       
56003       #line 905 "machine/pentium/disassembler.m"
56004       
56005 
56006               sprintf (str,  "DIVAL", DIS_EADDR8);
56007 
56008       
56009 
56010       
56011       
56012       
56013     } 
56014     goto MATCH_finished_a; 
56015     
56016   MATCH_label_a1160: (void)0; /*placeholder for label*/ 
56017     { 
56018       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56019       nextPC = 7 + MATCH_p; 
56020       
56021       #line 905 "machine/pentium/disassembler.m"
56022       
56023 
56024               sprintf (str,  "DIVAL", DIS_EADDR8);
56025 
56026       
56027 
56028       
56029       
56030       
56031     } 
56032     goto MATCH_finished_a; 
56033     
56034   MATCH_label_a1161: (void)0; /*placeholder for label*/ 
56035     { 
56036       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56037       nextPC = 6 + MATCH_p; 
56038       
56039       #line 905 "machine/pentium/disassembler.m"
56040       
56041 
56042               sprintf (str,  "DIVAL", DIS_EADDR8);
56043 
56044       
56045 
56046       
56047       
56048       
56049     } 
56050     goto MATCH_finished_a; 
56051     
56052   MATCH_label_a1162: (void)0; /*placeholder for label*/ 
56053     { 
56054       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56055       nextPC = 2 + MATCH_p; 
56056       
56057       #line 890 "machine/pentium/disassembler.m"
56058       
56059 
56060               sprintf (str,  "IDIV", DIS_EADDR8); /* ?? */
56061 
56062       
56063 
56064       //  | HLT() =>
56065 
56066       //      sprintf (str,  "HLT");
56067 
56068       
56069 
56070       
56071       
56072       
56073     } 
56074     goto MATCH_finished_a; 
56075     
56076   MATCH_label_a1163: (void)0; /*placeholder for label*/ 
56077     { 
56078       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56079       nextPC = 3 + MATCH_p; 
56080       
56081       #line 890 "machine/pentium/disassembler.m"
56082       
56083 
56084               sprintf (str,  "IDIV", DIS_EADDR8); /* ?? */
56085 
56086       
56087 
56088       //  | HLT() =>
56089 
56090       //      sprintf (str,  "HLT");
56091 
56092       
56093 
56094       
56095       
56096       
56097     } 
56098     goto MATCH_finished_a; 
56099     
56100   MATCH_label_a1164: (void)0; /*placeholder for label*/ 
56101     { 
56102       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56103       nextPC = 7 + MATCH_p; 
56104       
56105       #line 890 "machine/pentium/disassembler.m"
56106       
56107 
56108               sprintf (str,  "IDIV", DIS_EADDR8); /* ?? */
56109 
56110       
56111 
56112       //  | HLT() =>
56113 
56114       //      sprintf (str,  "HLT");
56115 
56116       
56117 
56118       
56119       
56120       
56121     } 
56122     goto MATCH_finished_a; 
56123     
56124   MATCH_label_a1165: (void)0; /*placeholder for label*/ 
56125     { 
56126       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56127       nextPC = 6 + MATCH_p; 
56128       
56129       #line 890 "machine/pentium/disassembler.m"
56130       
56131 
56132               sprintf (str,  "IDIV", DIS_EADDR8); /* ?? */
56133 
56134       
56135 
56136       //  | HLT() =>
56137 
56138       //      sprintf (str,  "HLT");
56139 
56140       
56141 
56142       
56143       
56144       
56145     } 
56146     goto MATCH_finished_a; 
56147     
56148   MATCH_label_a1166: (void)0; /*placeholder for label*/ 
56149     { 
56150       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56151       unsigned i32 = MATCH_w_32_16 /* i32 at 16 */;
56152       nextPC = 6 + MATCH_p; 
56153       
56154       #line 104 "machine/pentium/disassembler.m"
56155       
56156 
56157               sprintf (str,  "TEST.Ed.Id", DIS_EADDR32, DIS_I32);
56158 
56159       
56160 
56161       
56162       
56163       
56164     } 
56165     goto MATCH_finished_a; 
56166     
56167   MATCH_label_a1167: (void)0; /*placeholder for label*/ 
56168     { 
56169       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56170       unsigned i32 = MATCH_w_32_24 /* i32 at 24 */;
56171       nextPC = 7 + MATCH_p; 
56172       
56173       #line 104 "machine/pentium/disassembler.m"
56174       
56175 
56176               sprintf (str,  "TEST.Ed.Id", DIS_EADDR32, DIS_I32);
56177 
56178       
56179 
56180       
56181       
56182       
56183     } 
56184     goto MATCH_finished_a; 
56185     
56186   MATCH_label_a1168: (void)0; /*placeholder for label*/ 
56187     { 
56188       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56189       unsigned i32 = MATCH_w_32_56 /* i32 at 56 */;
56190       nextPC = 11 + MATCH_p; 
56191       
56192       #line 104 "machine/pentium/disassembler.m"
56193       
56194 
56195               sprintf (str,  "TEST.Ed.Id", DIS_EADDR32, DIS_I32);
56196 
56197       
56198 
56199       
56200       
56201       
56202     } 
56203     goto MATCH_finished_a; 
56204     
56205   MATCH_label_a1169: (void)0; /*placeholder for label*/ 
56206     { 
56207       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56208       unsigned i32 = MATCH_w_32_48 /* i32 at 48 */;
56209       nextPC = 10 + MATCH_p; 
56210       
56211       #line 104 "machine/pentium/disassembler.m"
56212       
56213 
56214               sprintf (str,  "TEST.Ed.Id", DIS_EADDR32, DIS_I32);
56215 
56216       
56217 
56218       
56219       
56220       
56221     } 
56222     goto MATCH_finished_a; 
56223     
56224   MATCH_label_a1170: (void)0; /*placeholder for label*/ 
56225     { 
56226       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56227       nextPC = 2 + MATCH_p; 
56228       
56229       #line 615 "machine/pentium/disassembler.m"
56230       
56231 
56232               sprintf (str,  "NOTod", DIS_EADDR32);
56233 
56234       
56235 
56236       
56237       
56238       
56239     } 
56240     goto MATCH_finished_a; 
56241     
56242   MATCH_label_a1171: (void)0; /*placeholder for label*/ 
56243     { 
56244       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56245       nextPC = 3 + MATCH_p; 
56246       
56247       #line 615 "machine/pentium/disassembler.m"
56248       
56249 
56250               sprintf (str,  "NOTod", DIS_EADDR32);
56251 
56252       
56253 
56254       
56255       
56256       
56257     } 
56258     goto MATCH_finished_a; 
56259     
56260   MATCH_label_a1172: (void)0; /*placeholder for label*/ 
56261     { 
56262       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56263       nextPC = 7 + MATCH_p; 
56264       
56265       #line 615 "machine/pentium/disassembler.m"
56266       
56267 
56268               sprintf (str,  "NOTod", DIS_EADDR32);
56269 
56270       
56271 
56272       
56273       
56274       
56275     } 
56276     goto MATCH_finished_a; 
56277     
56278   MATCH_label_a1173: (void)0; /*placeholder for label*/ 
56279     { 
56280       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56281       nextPC = 6 + MATCH_p; 
56282       
56283       #line 615 "machine/pentium/disassembler.m"
56284       
56285 
56286               sprintf (str,  "NOTod", DIS_EADDR32);
56287 
56288       
56289 
56290       
56291       
56292       
56293     } 
56294     goto MATCH_finished_a; 
56295     
56296   MATCH_label_a1174: (void)0; /*placeholder for label*/ 
56297     { 
56298       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56299       nextPC = 2 + MATCH_p; 
56300       
56301       #line 624 "machine/pentium/disassembler.m"
56302       
56303 
56304               sprintf (str,  "NEGod", DIS_EADDR32);
56305 
56306       
56307 
56308       
56309       
56310       
56311     } 
56312     goto MATCH_finished_a; 
56313     
56314   MATCH_label_a1175: (void)0; /*placeholder for label*/ 
56315     { 
56316       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56317       nextPC = 3 + MATCH_p; 
56318       
56319       #line 624 "machine/pentium/disassembler.m"
56320       
56321 
56322               sprintf (str,  "NEGod", DIS_EADDR32);
56323 
56324       
56325 
56326       
56327       
56328       
56329     } 
56330     goto MATCH_finished_a; 
56331     
56332   MATCH_label_a1176: (void)0; /*placeholder for label*/ 
56333     { 
56334       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56335       nextPC = 7 + MATCH_p; 
56336       
56337       #line 624 "machine/pentium/disassembler.m"
56338       
56339 
56340               sprintf (str,  "NEGod", DIS_EADDR32);
56341 
56342       
56343 
56344       
56345       
56346       
56347     } 
56348     goto MATCH_finished_a; 
56349     
56350   MATCH_label_a1177: (void)0; /*placeholder for label*/ 
56351     { 
56352       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56353       nextPC = 6 + MATCH_p; 
56354       
56355       #line 624 "machine/pentium/disassembler.m"
56356       
56357 
56358               sprintf (str,  "NEGod", DIS_EADDR32);
56359 
56360       
56361 
56362       
56363       
56364       
56365     } 
56366     goto MATCH_finished_a; 
56367     
56368   MATCH_label_a1178: (void)0; /*placeholder for label*/ 
56369     { 
56370       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56371       nextPC = 2 + MATCH_p; 
56372       
56373       #line 633 "machine/pentium/disassembler.m"
56374       
56375 
56376               sprintf (str,  "MUL.AXod", DIS_EADDR32);
56377 
56378       
56379 
56380       
56381       
56382       
56383     } 
56384     goto MATCH_finished_a; 
56385     
56386   MATCH_label_a1179: (void)0; /*placeholder for label*/ 
56387     { 
56388       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56389       nextPC = 3 + MATCH_p; 
56390       
56391       #line 633 "machine/pentium/disassembler.m"
56392       
56393 
56394               sprintf (str,  "MUL.AXod", DIS_EADDR32);
56395 
56396       
56397 
56398       
56399       
56400       
56401     } 
56402     goto MATCH_finished_a; 
56403     
56404   MATCH_label_a1180: (void)0; /*placeholder for label*/ 
56405     { 
56406       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56407       nextPC = 7 + MATCH_p; 
56408       
56409       #line 633 "machine/pentium/disassembler.m"
56410       
56411 
56412               sprintf (str,  "MUL.AXod", DIS_EADDR32);
56413 
56414       
56415 
56416       
56417       
56418       
56419     } 
56420     goto MATCH_finished_a; 
56421     
56422   MATCH_label_a1181: (void)0; /*placeholder for label*/ 
56423     { 
56424       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56425       nextPC = 6 + MATCH_p; 
56426       
56427       #line 633 "machine/pentium/disassembler.m"
56428       
56429 
56430               sprintf (str,  "MUL.AXod", DIS_EADDR32);
56431 
56432       
56433 
56434       
56435       
56436       
56437     } 
56438     goto MATCH_finished_a; 
56439     
56440   MATCH_label_a1182: (void)0; /*placeholder for label*/ 
56441     { 
56442       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56443       nextPC = 2 + MATCH_p; 
56444       
56445       #line 875 "machine/pentium/disassembler.m"
56446       
56447 
56448               sprintf (str,  "IMULod", DIS_EADDR32);
56449 
56450       
56451 
56452       
56453       
56454       
56455     } 
56456     goto MATCH_finished_a; 
56457     
56458   MATCH_label_a1183: (void)0; /*placeholder for label*/ 
56459     { 
56460       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56461       nextPC = 3 + MATCH_p; 
56462       
56463       #line 875 "machine/pentium/disassembler.m"
56464       
56465 
56466               sprintf (str,  "IMULod", DIS_EADDR32);
56467 
56468       
56469 
56470       
56471       
56472       
56473     } 
56474     goto MATCH_finished_a; 
56475     
56476   MATCH_label_a1184: (void)0; /*placeholder for label*/ 
56477     { 
56478       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56479       nextPC = 7 + MATCH_p; 
56480       
56481       #line 875 "machine/pentium/disassembler.m"
56482       
56483 
56484               sprintf (str,  "IMULod", DIS_EADDR32);
56485 
56486       
56487 
56488       
56489       
56490       
56491     } 
56492     goto MATCH_finished_a; 
56493     
56494   MATCH_label_a1185: (void)0; /*placeholder for label*/ 
56495     { 
56496       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56497       nextPC = 6 + MATCH_p; 
56498       
56499       #line 875 "machine/pentium/disassembler.m"
56500       
56501 
56502               sprintf (str,  "IMULod", DIS_EADDR32);
56503 
56504       
56505 
56506       
56507       
56508       
56509     } 
56510     goto MATCH_finished_a; 
56511     
56512   MATCH_label_a1186: (void)0; /*placeholder for label*/ 
56513     { 
56514       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56515       nextPC = 2 + MATCH_p; 
56516       
56517       #line 899 "machine/pentium/disassembler.m"
56518       
56519 
56520               sprintf (str,  "DIVeAX", DIS_EADDR32);
56521 
56522       
56523 
56524       
56525       
56526       
56527     } 
56528     goto MATCH_finished_a; 
56529     
56530   MATCH_label_a1187: (void)0; /*placeholder for label*/ 
56531     { 
56532       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56533       nextPC = 3 + MATCH_p; 
56534       
56535       #line 899 "machine/pentium/disassembler.m"
56536       
56537 
56538               sprintf (str,  "DIVeAX", DIS_EADDR32);
56539 
56540       
56541 
56542       
56543       
56544       
56545     } 
56546     goto MATCH_finished_a; 
56547     
56548   MATCH_label_a1188: (void)0; /*placeholder for label*/ 
56549     { 
56550       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56551       nextPC = 7 + MATCH_p; 
56552       
56553       #line 899 "machine/pentium/disassembler.m"
56554       
56555 
56556               sprintf (str,  "DIVeAX", DIS_EADDR32);
56557 
56558       
56559 
56560       
56561       
56562       
56563     } 
56564     goto MATCH_finished_a; 
56565     
56566   MATCH_label_a1189: (void)0; /*placeholder for label*/ 
56567     { 
56568       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56569       nextPC = 6 + MATCH_p; 
56570       
56571       #line 899 "machine/pentium/disassembler.m"
56572       
56573 
56574               sprintf (str,  "DIVeAX", DIS_EADDR32);
56575 
56576       
56577 
56578       
56579       
56580       
56581     } 
56582     goto MATCH_finished_a; 
56583     
56584   MATCH_label_a1190: (void)0; /*placeholder for label*/ 
56585     { 
56586       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56587       nextPC = 2 + MATCH_p; 
56588       
56589       #line 884 "machine/pentium/disassembler.m"
56590       
56591 
56592               sprintf (str,  "IDIVeAX", DIS_EADDR32);
56593 
56594       
56595 
56596       
56597       
56598       
56599     } 
56600     goto MATCH_finished_a; 
56601     
56602   MATCH_label_a1191: (void)0; /*placeholder for label*/ 
56603     { 
56604       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56605       nextPC = 3 + MATCH_p; 
56606       
56607       #line 884 "machine/pentium/disassembler.m"
56608       
56609 
56610               sprintf (str,  "IDIVeAX", DIS_EADDR32);
56611 
56612       
56613 
56614       
56615       
56616       
56617     } 
56618     goto MATCH_finished_a; 
56619     
56620   MATCH_label_a1192: (void)0; /*placeholder for label*/ 
56621     { 
56622       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56623       nextPC = 7 + MATCH_p; 
56624       
56625       #line 884 "machine/pentium/disassembler.m"
56626       
56627 
56628               sprintf (str,  "IDIVeAX", DIS_EADDR32);
56629 
56630       
56631 
56632       
56633       
56634       
56635     } 
56636     goto MATCH_finished_a; 
56637     
56638   MATCH_label_a1193: (void)0; /*placeholder for label*/ 
56639     { 
56640       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56641       nextPC = 6 + MATCH_p; 
56642       
56643       #line 884 "machine/pentium/disassembler.m"
56644       
56645 
56646               sprintf (str,  "IDIVeAX", DIS_EADDR32);
56647 
56648       
56649 
56650       
56651       
56652       
56653     } 
56654     goto MATCH_finished_a; 
56655     
56656   MATCH_label_a1194: (void)0; /*placeholder for label*/ 
56657     { 
56658       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56659       nextPC = 2 + MATCH_p; 
56660       
56661       #line 836 "machine/pentium/disassembler.m"
56662       
56663 
56664               sprintf (str,  "INC.Eb", DIS_EADDR8);
56665 
56666       
56667 
56668       //    | IN.eAX.DXod() =>
56669 
56670       //        sprintf (str,  "IN.eAX.DXod");
56671 
56672       
56673 
56674       //    | IN.eAX.DXow() =>
56675 
56676       //        sprintf (str,  "IN.eAX.DXow");
56677 
56678       
56679 
56680       //    | IN.AL.DX() =>
56681 
56682       //        sprintf (str,  "IN.AL.DX");
56683 
56684       
56685 
56686       //    | IN.eAX.Ibod(i8) =>
56687 
56688       //        sprintf (str,  "IN.eAX.Ibod", DIS_I8);
56689 
56690       
56691 
56692       //    | IN.eAX.Ibow(i8) =>
56693 
56694       //        sprintf (str,  "IN.eAX.Ibow", DIS_I8);
56695 
56696       
56697 
56698       //    | IN.AL.Ib(i8) =>
56699 
56700       //        sprintf (str,  "IN.AL.Ib", DIS_I8);
56701 
56702       
56703 
56704       
56705       
56706       
56707     } 
56708     goto MATCH_finished_a; 
56709     
56710   MATCH_label_a1195: (void)0; /*placeholder for label*/ 
56711     { 
56712       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56713       nextPC = 3 + MATCH_p; 
56714       
56715       #line 836 "machine/pentium/disassembler.m"
56716       
56717 
56718               sprintf (str,  "INC.Eb", DIS_EADDR8);
56719 
56720       
56721 
56722       //    | IN.eAX.DXod() =>
56723 
56724       //        sprintf (str,  "IN.eAX.DXod");
56725 
56726       
56727 
56728       //    | IN.eAX.DXow() =>
56729 
56730       //        sprintf (str,  "IN.eAX.DXow");
56731 
56732       
56733 
56734       //    | IN.AL.DX() =>
56735 
56736       //        sprintf (str,  "IN.AL.DX");
56737 
56738       
56739 
56740       //    | IN.eAX.Ibod(i8) =>
56741 
56742       //        sprintf (str,  "IN.eAX.Ibod", DIS_I8);
56743 
56744       
56745 
56746       //    | IN.eAX.Ibow(i8) =>
56747 
56748       //        sprintf (str,  "IN.eAX.Ibow", DIS_I8);
56749 
56750       
56751 
56752       //    | IN.AL.Ib(i8) =>
56753 
56754       //        sprintf (str,  "IN.AL.Ib", DIS_I8);
56755 
56756       
56757 
56758       
56759       
56760       
56761     } 
56762     goto MATCH_finished_a; 
56763     
56764   MATCH_label_a1196: (void)0; /*placeholder for label*/ 
56765     { 
56766       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56767       nextPC = 7 + MATCH_p; 
56768       
56769       #line 836 "machine/pentium/disassembler.m"
56770       
56771 
56772               sprintf (str,  "INC.Eb", DIS_EADDR8);
56773 
56774       
56775 
56776       //    | IN.eAX.DXod() =>
56777 
56778       //        sprintf (str,  "IN.eAX.DXod");
56779 
56780       
56781 
56782       //    | IN.eAX.DXow() =>
56783 
56784       //        sprintf (str,  "IN.eAX.DXow");
56785 
56786       
56787 
56788       //    | IN.AL.DX() =>
56789 
56790       //        sprintf (str,  "IN.AL.DX");
56791 
56792       
56793 
56794       //    | IN.eAX.Ibod(i8) =>
56795 
56796       //        sprintf (str,  "IN.eAX.Ibod", DIS_I8);
56797 
56798       
56799 
56800       //    | IN.eAX.Ibow(i8) =>
56801 
56802       //        sprintf (str,  "IN.eAX.Ibow", DIS_I8);
56803 
56804       
56805 
56806       //    | IN.AL.Ib(i8) =>
56807 
56808       //        sprintf (str,  "IN.AL.Ib", DIS_I8);
56809 
56810       
56811 
56812       
56813       
56814       
56815     } 
56816     goto MATCH_finished_a; 
56817     
56818   MATCH_label_a1197: (void)0; /*placeholder for label*/ 
56819     { 
56820       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56821       nextPC = 6 + MATCH_p; 
56822       
56823       #line 836 "machine/pentium/disassembler.m"
56824       
56825 
56826               sprintf (str,  "INC.Eb", DIS_EADDR8);
56827 
56828       
56829 
56830       //    | IN.eAX.DXod() =>
56831 
56832       //        sprintf (str,  "IN.eAX.DXod");
56833 
56834       
56835 
56836       //    | IN.eAX.DXow() =>
56837 
56838       //        sprintf (str,  "IN.eAX.DXow");
56839 
56840       
56841 
56842       //    | IN.AL.DX() =>
56843 
56844       //        sprintf (str,  "IN.AL.DX");
56845 
56846       
56847 
56848       //    | IN.eAX.Ibod(i8) =>
56849 
56850       //        sprintf (str,  "IN.eAX.Ibod", DIS_I8);
56851 
56852       
56853 
56854       //    | IN.eAX.Ibow(i8) =>
56855 
56856       //        sprintf (str,  "IN.eAX.Ibow", DIS_I8);
56857 
56858       
56859 
56860       //    | IN.AL.Ib(i8) =>
56861 
56862       //        sprintf (str,  "IN.AL.Ib", DIS_I8);
56863 
56864       
56865 
56866       
56867       
56868       
56869     } 
56870     goto MATCH_finished_a; 
56871     
56872   MATCH_label_a1198: (void)0; /*placeholder for label*/ 
56873     { 
56874       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56875       nextPC = 2 + MATCH_p; 
56876       
56877       #line 920 "machine/pentium/disassembler.m"
56878       
56879 
56880               sprintf (str,  "DEC.Eb", DIS_EADDR8);
56881 
56882       
56883 
56884       
56885       
56886       
56887     } 
56888     goto MATCH_finished_a; 
56889     
56890   MATCH_label_a1199: (void)0; /*placeholder for label*/ 
56891     { 
56892       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56893       nextPC = 3 + MATCH_p; 
56894       
56895       #line 920 "machine/pentium/disassembler.m"
56896       
56897 
56898               sprintf (str,  "DEC.Eb", DIS_EADDR8);
56899 
56900       
56901 
56902       
56903       
56904       
56905     } 
56906     goto MATCH_finished_a; 
56907     
56908   MATCH_label_a1200: (void)0; /*placeholder for label*/ 
56909     { 
56910       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56911       nextPC = 7 + MATCH_p; 
56912       
56913       #line 920 "machine/pentium/disassembler.m"
56914       
56915 
56916               sprintf (str,  "DEC.Eb", DIS_EADDR8);
56917 
56918       
56919 
56920       
56921       
56922       
56923     } 
56924     goto MATCH_finished_a; 
56925     
56926   MATCH_label_a1201: (void)0; /*placeholder for label*/ 
56927     { 
56928       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56929       nextPC = 6 + MATCH_p; 
56930       
56931       #line 920 "machine/pentium/disassembler.m"
56932       
56933 
56934               sprintf (str,  "DEC.Eb", DIS_EADDR8);
56935 
56936       
56937 
56938       
56939       
56940       
56941     } 
56942     goto MATCH_finished_a; 
56943     
56944   MATCH_label_a1202: (void)0; /*placeholder for label*/ 
56945     { 
56946       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56947       nextPC = 2 + MATCH_p; 
56948       
56949       #line 830 "machine/pentium/disassembler.m"
56950       
56951 
56952               sprintf (str,  "INC.Evod", DIS_EADDR32);
56953 
56954       
56955 
56956       
56957       
56958       
56959     } 
56960     goto MATCH_finished_a; 
56961     
56962   MATCH_label_a1203: (void)0; /*placeholder for label*/ 
56963     { 
56964       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56965       nextPC = 3 + MATCH_p; 
56966       
56967       #line 830 "machine/pentium/disassembler.m"
56968       
56969 
56970               sprintf (str,  "INC.Evod", DIS_EADDR32);
56971 
56972       
56973 
56974       
56975       
56976       
56977     } 
56978     goto MATCH_finished_a; 
56979     
56980   MATCH_label_a1204: (void)0; /*placeholder for label*/ 
56981     { 
56982       unsigned Eaddr = 1 + addressToPC(MATCH_p);
56983       nextPC = 7 + MATCH_p; 
56984       
56985       #line 830 "machine/pentium/disassembler.m"
56986       
56987 
56988               sprintf (str,  "INC.Evod", DIS_EADDR32);
56989 
56990       
56991 
56992       
56993       
56994       
56995     } 
56996     goto MATCH_finished_a; 
56997     
56998   MATCH_label_a1205: (void)0; /*placeholder for label*/ 
56999     { 
57000       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57001       nextPC = 6 + MATCH_p; 
57002       
57003       #line 830 "machine/pentium/disassembler.m"
57004       
57005 
57006               sprintf (str,  "INC.Evod", DIS_EADDR32);
57007 
57008       
57009 
57010       
57011       
57012       
57013     } 
57014     goto MATCH_finished_a; 
57015     
57016   MATCH_label_a1206: (void)0; /*placeholder for label*/ 
57017     { 
57018       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57019       nextPC = 2 + MATCH_p; 
57020       
57021       #line 914 "machine/pentium/disassembler.m"
57022       
57023 
57024               sprintf (str,  "DEC.Evod", DIS_EADDR32);
57025 
57026       
57027 
57028       
57029       
57030       
57031     } 
57032     goto MATCH_finished_a; 
57033     
57034   MATCH_label_a1207: (void)0; /*placeholder for label*/ 
57035     { 
57036       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57037       nextPC = 3 + MATCH_p; 
57038       
57039       #line 914 "machine/pentium/disassembler.m"
57040       
57041 
57042               sprintf (str,  "DEC.Evod", DIS_EADDR32);
57043 
57044       
57045 
57046       
57047       
57048       
57049     } 
57050     goto MATCH_finished_a; 
57051     
57052   MATCH_label_a1208: (void)0; /*placeholder for label*/ 
57053     { 
57054       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57055       nextPC = 7 + MATCH_p; 
57056       
57057       #line 914 "machine/pentium/disassembler.m"
57058       
57059 
57060               sprintf (str,  "DEC.Evod", DIS_EADDR32);
57061 
57062       
57063 
57064       
57065       
57066       
57067     } 
57068     goto MATCH_finished_a; 
57069     
57070   MATCH_label_a1209: (void)0; /*placeholder for label*/ 
57071     { 
57072       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57073       nextPC = 6 + MATCH_p; 
57074       
57075       #line 914 "machine/pentium/disassembler.m"
57076       
57077 
57078               sprintf (str,  "DEC.Evod", DIS_EADDR32);
57079 
57080       
57081 
57082       
57083       
57084       
57085     } 
57086     goto MATCH_finished_a; 
57087     
57088   MATCH_label_a1210: (void)0; /*placeholder for label*/ 
57089     { 
57090       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57091       nextPC = 2 + MATCH_p; 
57092       
57093       #line 989 "machine/pentium/disassembler.m"
57094       
57095 
57096               sprintf (str,  "CALL.Evod", DIS_EADDR32);
57097 
57098       
57099 
57100       
57101       
57102       
57103     } 
57104     goto MATCH_finished_a; 
57105     
57106   MATCH_label_a1211: (void)0; /*placeholder for label*/ 
57107     { 
57108       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57109       nextPC = 3 + MATCH_p; 
57110       
57111       #line 989 "machine/pentium/disassembler.m"
57112       
57113 
57114               sprintf (str,  "CALL.Evod", DIS_EADDR32);
57115 
57116       
57117 
57118       
57119       
57120       
57121     } 
57122     goto MATCH_finished_a; 
57123     
57124   MATCH_label_a1212: (void)0; /*placeholder for label*/ 
57125     { 
57126       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57127       nextPC = 7 + MATCH_p; 
57128       
57129       #line 989 "machine/pentium/disassembler.m"
57130       
57131 
57132               sprintf (str,  "CALL.Evod", DIS_EADDR32);
57133 
57134       
57135 
57136       
57137       
57138       
57139     } 
57140     goto MATCH_finished_a; 
57141     
57142   MATCH_label_a1213: (void)0; /*placeholder for label*/ 
57143     { 
57144       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57145       nextPC = 6 + MATCH_p; 
57146       
57147       #line 989 "machine/pentium/disassembler.m"
57148       
57149 
57150               sprintf (str,  "CALL.Evod", DIS_EADDR32);
57151 
57152       
57153 
57154       
57155       
57156       
57157     } 
57158     goto MATCH_finished_a; 
57159     
57160   MATCH_label_a1214: (void)0; /*placeholder for label*/ 
57161     { 
57162       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57163       nextPC = 2 + MATCH_p; 
57164       
57165       #line 543 "machine/pentium/disassembler.m"
57166       
57167 
57168               sprintf (str,  "PUSH.Evod", DIS_EADDR32);
57169 
57170       
57171 
57172       
57173       
57174       
57175     } 
57176     goto MATCH_finished_a; 
57177     
57178   MATCH_label_a1215: (void)0; /*placeholder for label*/ 
57179     { 
57180       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57181       nextPC = 3 + MATCH_p; 
57182       
57183       #line 543 "machine/pentium/disassembler.m"
57184       
57185 
57186               sprintf (str,  "PUSH.Evod", DIS_EADDR32);
57187 
57188       
57189 
57190       
57191       
57192       
57193     } 
57194     goto MATCH_finished_a; 
57195     
57196   MATCH_label_a1216: (void)0; /*placeholder for label*/ 
57197     { 
57198       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57199       nextPC = 7 + MATCH_p; 
57200       
57201       #line 543 "machine/pentium/disassembler.m"
57202       
57203 
57204               sprintf (str,  "PUSH.Evod", DIS_EADDR32);
57205 
57206       
57207 
57208       
57209       
57210       
57211     } 
57212     goto MATCH_finished_a; 
57213     
57214   MATCH_label_a1217: (void)0; /*placeholder for label*/ 
57215     { 
57216       unsigned Eaddr = 1 + addressToPC(MATCH_p);
57217       nextPC = 6 + MATCH_p; 
57218       
57219       #line 543 "machine/pentium/disassembler.m"
57220       
57221 
57222               sprintf (str,  "PUSH.Evod", DIS_EADDR32);
57223 
57224       
57225 
57226       
57227       
57228       
57229     } 
57230     goto MATCH_finished_a; 
57231     
57232   MATCH_finished_a: (void)0; /*placeholder for label*/
57233   
57234 }
57235 
57236 #line 1796 "machine/pentium/disassembler.m"
57237 
57238     // return # of bytes parsed
57239     return (nextPC - hostPC);
57240 }
57241 
57242 
57243 

Generated on Tue Sep 19 21:18:22 2006 for Boomerang by  doxygen 1.4.6