frontend » machine » pentium

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