opcodes/rx-decode.c

   1 #line 1 "rx-decode.opc"
   2 /* -*- c -*- */
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6
   7 #include "config.h"
   8 #include "ansidecl.h"
   9 #include "opcode/rx.h"
  10
  11 #define RX_OPCODE_BIG_ENDIAN 0
  12
  13 typedef struct
  14 {
  15   RX_Opcode_Decoded * rx;
  16   int (* getbyte)(void *);
  17   void * ptr;
  18   unsigned char * op;
  19 } LocalData;
  20
  21 static int trace = 0;
  22
  23 #define BSIZE 0
  24 #define WSIZE 1
  25 #define LSIZE 2
  26
  27 /* These are for when the upper bits are "don't care" or "undefined".  */
  28 static int bwl[] =
  29 {
  30   RX_Byte,
  31   RX_Word,
  32   RX_Long
  33 };
  34
  35 static int sbwl[] =
  36 {
  37   RX_SByte,
  38   RX_SWord,
  39   RX_Long
  40 };
  41
  42 static int ubwl[] =
  43 {
  44   RX_UByte,
  45   RX_UWord,
  46   RX_Long
  47 };
  48
  49 static int memex[] =
  50 {
  51   RX_SByte,
  52   RX_SWord,
  53   RX_Long,
  54   RX_UWord
  55 };
  56
  57 #define ID(x) rx->id = RXO_##x
  58 #define OP(n,t,r,a) (rx->op[n].type = t, \
  59                      rx->op[n].reg = r,      \
  60                      rx->op[n].addend = a )
  61 #define OPs(n,t,r,a,s) (OP (n,t,r,a), \
  62                         rx->op[n].size = s )
  63
  64 /* This is for the BWL and BW bitfields.  */
  65 static int SCALE[] = { 1, 2, 4 };
  66 /* This is for the prefix size enum.  */
  67 static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
  68
  69 static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
  70                        16, 17, 0, 0, 0, 0, 0, 0 };
  71
  72 static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
  73
  74 /*
  75  *C     a constant (immediate) c
  76  *R     A register
  77  *I     Register indirect, no offset
  78  *Is    Register indirect, with offset
  79  *D     standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
  80  *P     standard displacement: type (r,[r]), reg, assumes UByte
  81  *Pm    memex displacement: type (r,[r]), reg, memex code
  82  *cc    condition code.  */
  83
  84 #define DC(c)       OP (0, RX_Operand_Immediate, 0, c)
  85 #define DR(r)       OP (0, RX_Operand_Register,  r, 0)
  86 #define DI(r,a)     OP (0, RX_Operand_Indirect,  r, a)
  87 #define DIs(r,a,s)  OP (0, RX_Operand_Indirect,  r, (a) * SCALE[s])
  88 #define DD(t,r,s)   rx_disp (0, t, r, bwl[s], ld);
  89 #define DF(r)       OP (0, RX_Operand_Flag,  flagmap[r], 0)
  90
  91 #define SC(i)       OP (1, RX_Operand_Immediate, 0, i)
  92 #define SR(r)       OP (1, RX_Operand_Register,  r, 0)
  93 #define SI(r,a)     OP (1, RX_Operand_Indirect,  r, a)
  94 #define SIs(r,a,s)  OP (1, RX_Operand_Indirect,  r, (a) * SCALE[s])
  95 #define SD(t,r,s)   rx_disp (1, t, r, bwl[s], ld);
  96 #define SP(t,r)     rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
  97 #define SPm(t,r,m)  rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
  98 #define Scc(cc)     OP (1, RX_Operand_Condition,  cc, 0)
  99
 100 #define S2C(i)      OP (2, RX_Operand_Immediate, 0, i)
 101 #define S2R(r)      OP (2, RX_Operand_Register,  r, 0)
 102 #define S2I(r,a)    OP (2, RX_Operand_Indirect,  r, a)
 103 #define S2Is(r,a,s) OP (2, RX_Operand_Indirect,  r, (a) * SCALE[s])
 104 #define S2D(t,r,s)  rx_disp (2, t, r, bwl[s], ld);
 105 #define S2P(t,r)    rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
 106 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
 107 #define S2cc(cc)    OP (2, RX_Operand_Condition,  cc, 0)
 108
 109 #define BWL(sz)     rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
 110 #define sBWL(sz)    rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
 111 #define uBWL(sz)    rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubwl[sz]
 112 #define P(t, n)     rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
 113
 114 #define F(f) store_flags(rx, f)
 115
 116 #define AU ATTRIBUTE_UNUSED
 117 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
 118
 119 #define SYNTAX(x) rx->syntax = x
 120
 121 #define UNSUPPORTED() \
 122   rx->syntax = "*unknown*"
 123
 124 #define IMM(sf)   immediate (sf, 0, ld)
 125 #define IMMex(sf) immediate (sf, 1, ld)
 126
 127 static int
 128 immediate (int sfield, int ex, LocalData * ld)
 129 {
 130   unsigned long i = 0, j;
 131
 132   switch (sfield)
 133     {
 134 #define B ((unsigned long) GETBYTE())
 135     case 0:
 136 #if RX_OPCODE_BIG_ENDIAN
 137       i  = B;
 138       if (ex && (i & 0x80))
 139         i -= 0x100;
 140       i <<= 24;
 141       i |= B << 16;
 142       i |= B << 8;
 143       i |= B;
 144 #else
 145       i = B;
 146       i |= B << 8;
 147       i |= B << 16;
 148       j = B;
 149       if (ex && (j & 0x80))
 150         j -= 0x100;
 151       i |= j << 24;
 152 #endif
 153       break;
 154     case 3:
 155 #if RX_OPCODE_BIG_ENDIAN
 156       i  = B << 16;
 157       i |= B << 8;
 158       i |= B;
 159 #else
 160       i  = B;
 161       i |= B << 8;
 162       i |= B << 16;
 163 #endif
 164       if (ex && (i & 0x800000))
 165         i -= 0x1000000;
 166       break;
 167     case 2:
 168 #if RX_OPCODE_BIG_ENDIAN
 169       i |= B << 8;
 170       i |= B;
 171 #else
 172       i |= B;
 173       i |= B << 8;
 174 #endif
 175       if (ex && (i & 0x8000))
 176         i -= 0x10000;
 177       break;
 178     case 1:
 179       i |= B;
 180       if (ex && (i & 0x80))
 181         i -= 0x100;
 182       break;
 183     default:
 184       abort();
 185     }
 186   return i;
 187 }
 188
 189 static void
 190 rx_disp (int n, int type, int reg, int size, LocalData * ld)
 191 {
 192   int disp;
 193
 194   ld->rx->op[n].reg = reg;
 195   switch (type)
 196     {
 197     case 3:
 198       ld->rx->op[n].type = RX_Operand_Register;
 199       break;
 200     case 0:
 201       ld->rx->op[n].type = RX_Operand_Indirect;
 202       ld->rx->op[n].addend = 0;
 203       break;
 204     case 1:
 205       ld->rx->op[n].type = RX_Operand_Indirect;
 206       disp = GETBYTE ();
 207       ld->rx->op[n].addend = disp * PSCALE[size];
 208       break;
 209     case 2:
 210       ld->rx->op[n].type = RX_Operand_Indirect;
 211       disp = GETBYTE ();
 212 #if RX_OPCODE_BIG_ENDIAN
 213       disp = disp * 256 + GETBYTE ();
 214 #else
 215       disp = disp + GETBYTE () * 256;
 216 #endif
 217       ld->rx->op[n].addend = disp * PSCALE[size];
 218       break;
 219     default:
 220       abort ();
 221     }
 222 }
 223
 224 /* The syntax is "OSZC" where each character is one of the following:
 225    - = flag unchanged
 226    0 = flag cleared
 227    1 = flag set
 228    ? = flag undefined
 229    x = flag set (any letter will do, use it for hints :).  */
 230
 231 static void
 232 store_flags (RX_Opcode_Decoded * rx, char * str)
 233 {
 234   int i, mask;
 235   rx->flags_0 = 0;
 236   rx->flags_1 = 0;
 237   rx->flags_s = 0;
 238
 239   for (i = 0; i < 4; i++)
 240     {
 241       mask = 8 >> i;
 242       switch (str[i])
 243         {
 244         case 0:
 245           abort ();
 246         case '-':
 247           break;
 248         case '0':
 249           rx->flags_0 |= mask;
 250           break;
 251         case '1':
 252           rx->flags_1 |= mask;
 253           break;
 254         case '?':
 255           break;
 256         default:
 257           rx->flags_0 |= mask;
 258           rx->flags_s |= mask;
 259           break;
 260         }
 261     }
 262 }
 263
 264 int
 265 rx_decode_opcode (unsigned long pc AU,
 266                   RX_Opcode_Decoded * rx,
 267                   int (* getbyte)(void *),
 268                   void * ptr)
 269 {
 270   LocalData lds, * ld = &lds;
 271   unsigned char op[20] = {0};
 272
 273   lds.rx = rx;
 274   lds.getbyte = getbyte;
 275   lds.ptr = ptr;
 276   lds.op = op;
 277
 278   memset (rx, 0, sizeof (*rx));
 279   BWL(LSIZE);
 280
 281
 282 /*----------------------------------------------------------------------*/
 283 /* MOV                                                                  */
 284
 285   GETBYTE ();
 286   switch (op[0] & 0xff)
 287   {
 288     case 0x00:
 289         {
 290           /** 0000 0000                 brk */
 291           if (trace)
 292             {
 293               printf ("\033[33m%s\033[0m  %02x\n",
 294                      "/** 0000 0000                     brk */",
 295                      op[0]);
 296             }
 297           SYNTAX("brk");
 298 #line 951 "rx-decode.opc"
 299           ID(brk);
 300
 301         }
 302       break;
 303     case 0x01:
 304         {
 305           /** 0000 0001                 dbt */
 306           if (trace)
 307             {
 308               printf ("\033[33m%s\033[0m  %02x\n",
 309                      "/** 0000 0001                     dbt */",
 310                      op[0]);
 311             }
 312           SYNTAX("dbt");
 313 #line 954 "rx-decode.opc"
 314           ID(dbt);
 315
 316         }
 317       break;
 318     case 0x02:
 319         {
 320           /** 0000 0010                 rts */
 321           if (trace)
 322             {
 323               printf ("\033[33m%s\033[0m  %02x\n",
 324                      "/** 0000 0010                     rts */",
 325                      op[0]);
 326             }
 327           SYNTAX("rts");
 328 #line 740 "rx-decode.opc"
 329           ID(rts);
 330
 331         /*----------------------------------------------------------------------*/
 332         /* NOP                                                          */
 333
 334         }
 335       break;
 336     case 0x03:
 337         {
 338           /** 0000 0011                 nop */
 339           if (trace)
 340             {
 341               printf ("\033[33m%s\033[0m  %02x\n",
 342                      "/** 0000 0011                     nop */",
 343                      op[0]);
 344             }
 345           SYNTAX("nop");
 346 #line 746 "rx-decode.opc"
 347           ID(nop);
 348
 349         /*----------------------------------------------------------------------*/
 350         /* STRING FUNCTIONS                                                     */
 351
 352         }
 353       break;
 354     case 0x04:
 355         {
 356           /** 0000 0100                 bra.a   %a0 */
 357           if (trace)
 358             {
 359               printf ("\033[33m%s\033[0m  %02x\n",
 360                      "/** 0000 0100                     bra.a   %a0 */",
 361                      op[0]);
 362             }
 363           SYNTAX("bra.a %a0");
 364 #line 718 "rx-decode.opc"
 365           ID(branch); Scc(RXC_always); DC(pc + IMMex(3));
 366
 367         }
 368       break;
 369     case 0x05:
 370         {
 371           /** 0000 0101                 bsr.a   %a0 */
 372           if (trace)
 373             {
 374               printf ("\033[33m%s\033[0m  %02x\n",
 375                      "/** 0000 0101                     bsr.a   %a0 */",
 376                      op[0]);
 377             }
 378           SYNTAX("bsr.a %a0");
 379 #line 734 "rx-decode.opc"
 380           ID(jsr); DC(pc + IMMex(3));
 381
 382         }
 383       break;
 384     case 0x06:
 385         GETBYTE ();
 386         switch (op[1] & 0xff)
 387         {
 388           case 0x00:
 389               GETBYTE ();
 390               switch (op[2] & 0x00)
 391               {
 392                 case 0x00:
 393                   op_semantics_1:
 394                     {
 395                       /** 0000 0110 mx00 00ss rsrc rdst                 sub     %2%S2, %1 */
 396 #line 522 "rx-decode.opc"
 397                       int mx AU = (op[1] >> 6) & 0x03;
 398 #line 522 "rx-decode.opc"
 399                       int ss AU = op[1] & 0x03;
 400 #line 522 "rx-decode.opc"
 401                       int rsrc AU = (op[2] >> 4) & 0x0f;
 402 #line 522 "rx-decode.opc"
 403                       int rdst AU = op[2] & 0x0f;
 404                       if (trace)
 405                         {
 406                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 407                                  "/** 0000 0110 mx00 00ss rsrc rdst                     sub     %2%S2, %1 */",
 408                                  op[0], op[1], op[2]);
 409                           printf ("  mx = 0x%x,", mx);
 410                           printf ("  ss = 0x%x,", ss);
 411                           printf ("  rsrc = 0x%x,", rsrc);
 412                           printf ("  rdst = 0x%x\n", rdst);
 413                         }
 414                       SYNTAX("sub       %2%S2, %1");
 415 #line 522 "rx-decode.opc"
 416                       ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F("OSZC");
 417
 418                     }
 419                   break;
 420               }
 421             break;
 422           case 0x01:
 423               GETBYTE ();
 424               switch (op[2] & 0x00)
 425               {
 426                 case 0x00:
 427                   goto op_semantics_1;
 428                   break;
 429               }
 430             break;
 431           case 0x02:
 432               GETBYTE ();
 433               switch (op[2] & 0x00)
 434               {
 435                 case 0x00:
 436                   goto op_semantics_1;
 437                   break;
 438               }
 439             break;
 440           case 0x03:
 441               GETBYTE ();
 442               switch (op[2] & 0x00)
 443               {
 444                 case 0x00:
 445                   goto op_semantics_1;
 446                   break;
 447               }
 448             break;
 449           case 0x04:
 450               GETBYTE ();
 451               switch (op[2] & 0x00)
 452               {
 453                 case 0x00:
 454                   op_semantics_2:
 455                     {
 456                       /** 0000 0110 mx00 01ss rsrc rdst         cmp     %2%S2, %1 */
 457 #line 510 "rx-decode.opc"
 458                       int mx AU = (op[1] >> 6) & 0x03;
 459 #line 510 "rx-decode.opc"
 460                       int ss AU = op[1] & 0x03;
 461 #line 510 "rx-decode.opc"
 462                       int rsrc AU = (op[2] >> 4) & 0x0f;
 463 #line 510 "rx-decode.opc"
 464                       int rdst AU = op[2] & 0x0f;
 465                       if (trace)
 466                         {
 467                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 468                                  "/** 0000 0110 mx00 01ss rsrc rdst             cmp     %2%S2, %1 */",
 469                                  op[0], op[1], op[2]);
 470                           printf ("  mx = 0x%x,", mx);
 471                           printf ("  ss = 0x%x,", ss);
 472                           printf ("  rsrc = 0x%x,", rsrc);
 473                           printf ("  rdst = 0x%x\n", rdst);
 474                         }
 475                       SYNTAX("cmp       %2%S2, %1");
 476 #line 510 "rx-decode.opc"
 477                       ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F("OSZC");
 478
 479                     /*----------------------------------------------------------------------*/
 480                     /* SUB                                                                      */
 481
 482                     }
 483                   break;
 484               }
 485             break;
 486           case 0x05:
 487               GETBYTE ();
 488               switch (op[2] & 0x00)
 489               {
 490                 case 0x00:
 491                   goto op_semantics_2;
 492                   break;
 493               }
 494             break;
 495           case 0x06:
 496               GETBYTE ();
 497               switch (op[2] & 0x00)
 498               {
 499                 case 0x00:
 500                   goto op_semantics_2;
 501                   break;
 502               }
 503             break;
 504           case 0x07:
 505               GETBYTE ();
 506               switch (op[2] & 0x00)
 507               {
 508                 case 0x00:
 509                   goto op_semantics_2;
 510                   break;
 511               }
 512             break;
 513           case 0x08:
 514               GETBYTE ();
 515               switch (op[2] & 0x00)
 516               {
 517                 case 0x00:
 518                   op_semantics_3:
 519                     {
 520                       /** 0000 0110 mx00 10ss rsrc rdst add     %1%S1, %0 */
 521 #line 486 "rx-decode.opc"
 522                       int mx AU = (op[1] >> 6) & 0x03;
 523 #line 486 "rx-decode.opc"
 524                       int ss AU = op[1] & 0x03;
 525 #line 486 "rx-decode.opc"
 526                       int rsrc AU = (op[2] >> 4) & 0x0f;
 527 #line 486 "rx-decode.opc"
 528                       int rdst AU = op[2] & 0x0f;
 529                       if (trace)
 530                         {
 531                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 532                                  "/** 0000 0110 mx00 10ss rsrc rdst     add     %1%S1, %0 */",
 533                                  op[0], op[1], op[2]);
 534                           printf ("  mx = 0x%x,", mx);
 535                           printf ("  ss = 0x%x,", ss);
 536                           printf ("  rsrc = 0x%x,", rsrc);
 537                           printf ("  rdst = 0x%x\n", rdst);
 538                         }
 539                       SYNTAX("add       %1%S1, %0");
 540 #line 486 "rx-decode.opc"
 541                       ID(add); SPm(ss, rsrc, mx); DR(rdst); F("OSZC");
 542
 543                     }
 544                   break;
 545               }
 546             break;
 547           case 0x09:
 548               GETBYTE ();
 549               switch (op[2] & 0x00)
 550               {
 551                 case 0x00:
 552                   goto op_semantics_3;
 553                   break;
 554               }
 555             break;
 556           case 0x0a:
 557               GETBYTE ();
 558               switch (op[2] & 0x00)
 559               {
 560                 case 0x00:
 561                   goto op_semantics_3;
 562                   break;
 563               }
 564             break;
 565           case 0x0b:
 566               GETBYTE ();
 567               switch (op[2] & 0x00)
 568               {
 569                 case 0x00:
 570                   goto op_semantics_3;
 571                   break;
 572               }
 573             break;
 574           case 0x0c:
 575               GETBYTE ();
 576               switch (op[2] & 0x00)
 577               {
 578                 case 0x00:
 579                   op_semantics_4:
 580                     {
 581                       /** 0000 0110 mx00 11ss rsrc rdst mul     %1%S1, %0 */
 582 #line 583 "rx-decode.opc"
 583                       int mx AU = (op[1] >> 6) & 0x03;
 584 #line 583 "rx-decode.opc"
 585                       int ss AU = op[1] & 0x03;
 586 #line 583 "rx-decode.opc"
 587                       int rsrc AU = (op[2] >> 4) & 0x0f;
 588 #line 583 "rx-decode.opc"
 589                       int rdst AU = op[2] & 0x0f;
 590                       if (trace)
 591                         {
 592                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 593                                  "/** 0000 0110 mx00 11ss rsrc rdst     mul     %1%S1, %0 */",
 594                                  op[0], op[1], op[2]);
 595                           printf ("  mx = 0x%x,", mx);
 596                           printf ("  ss = 0x%x,", ss);
 597                           printf ("  rsrc = 0x%x,", rsrc);
 598                           printf ("  rdst = 0x%x\n", rdst);
 599                         }
 600                       SYNTAX("mul       %1%S1, %0");
 601 #line 583 "rx-decode.opc"
 602                       ID(mul); SPm(ss, rsrc, mx); DR(rdst); F("----");
 603
 604                     }
 605                   break;
 606               }
 607             break;
 608           case 0x0d:
 609               GETBYTE ();
 610               switch (op[2] & 0x00)
 611               {
 612                 case 0x00:
 613                   goto op_semantics_4;
 614                   break;
 615               }
 616             break;
 617           case 0x0e:
 618               GETBYTE ();
 619               switch (op[2] & 0x00)
 620               {
 621                 case 0x00:
 622                   goto op_semantics_4;
 623                   break;
 624               }
 625             break;
 626           case 0x0f:
 627               GETBYTE ();
 628               switch (op[2] & 0x00)
 629               {
 630                 case 0x00:
 631                   goto op_semantics_4;
 632                   break;
 633               }
 634             break;
 635           case 0x10:
 636               GETBYTE ();
 637               switch (op[2] & 0x00)
 638               {
 639                 case 0x00:
 640                   op_semantics_5:
 641                     {
 642                       /** 0000 0110 mx01 00ss rsrc rdst and     %1%S1, %0 */
 643 #line 399 "rx-decode.opc"
 644                       int mx AU = (op[1] >> 6) & 0x03;
 645 #line 399 "rx-decode.opc"
 646                       int ss AU = op[1] & 0x03;
 647 #line 399 "rx-decode.opc"
 648                       int rsrc AU = (op[2] >> 4) & 0x0f;
 649 #line 399 "rx-decode.opc"
 650                       int rdst AU = op[2] & 0x0f;
 651                       if (trace)
 652                         {
 653                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 654                                  "/** 0000 0110 mx01 00ss rsrc rdst     and     %1%S1, %0 */",
 655                                  op[0], op[1], op[2]);
 656                           printf ("  mx = 0x%x,", mx);
 657                           printf ("  ss = 0x%x,", ss);
 658                           printf ("  rsrc = 0x%x,", rsrc);
 659                           printf ("  rdst = 0x%x\n", rdst);
 660                         }
 661                       SYNTAX("and       %1%S1, %0");
 662 #line 399 "rx-decode.opc"
 663                       ID(and); SPm(ss, rsrc, mx); DR(rdst); F("-SZ-");
 664
 665                     }
 666                   break;
 667               }
 668             break;
 669           case 0x11:
 670               GETBYTE ();
 671               switch (op[2] & 0x00)
 672               {
 673                 case 0x00:
 674                   goto op_semantics_5;
 675                   break;
 676               }
 677             break;
 678           case 0x12:
 679               GETBYTE ();
 680               switch (op[2] & 0x00)
 681               {
 682                 case 0x00:
 683                   goto op_semantics_5;
 684                   break;
 685               }
 686             break;
 687           case 0x13:
 688               GETBYTE ();
 689               switch (op[2] & 0x00)
 690               {
 691                 case 0x00:
 692                   goto op_semantics_5;
 693                   break;
 694               }
 695             break;
 696           case 0x14:
 697               GETBYTE ();
 698               switch (op[2] & 0x00)
 699               {
 700                 case 0x00:
 701                   op_semantics_6:
 702                     {
 703                       /** 0000 0110 mx01 01ss rsrc rdst                 or      %1%S1, %0 */
 704 #line 417 "rx-decode.opc"
 705                       int mx AU = (op[1] >> 6) & 0x03;
 706 #line 417 "rx-decode.opc"
 707                       int ss AU = op[1] & 0x03;
 708 #line 417 "rx-decode.opc"
 709                       int rsrc AU = (op[2] >> 4) & 0x0f;
 710 #line 417 "rx-decode.opc"
 711                       int rdst AU = op[2] & 0x0f;
 712                       if (trace)
 713                         {
 714                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 715                                  "/** 0000 0110 mx01 01ss rsrc rdst                     or      %1%S1, %0 */",
 716                                  op[0], op[1], op[2]);
 717                           printf ("  mx = 0x%x,", mx);
 718                           printf ("  ss = 0x%x,", ss);
 719                           printf ("  rsrc = 0x%x,", rsrc);
 720                           printf ("  rdst = 0x%x\n", rdst);
 721                         }
 722                       SYNTAX("or        %1%S1, %0");
 723 #line 417 "rx-decode.opc"
 724                       ID(or); SPm(ss, rsrc, mx); DR(rdst); F("-SZ-");
 725
 726                     }
 727                   break;
 728               }
 729             break;
 730           case 0x15:
 731               GETBYTE ();
 732               switch (op[2] & 0x00)
 733               {
 734                 case 0x00:
 735                   goto op_semantics_6;
 736                   break;
 737               }
 738             break;
 739           case 0x16:
 740               GETBYTE ();
 741               switch (op[2] & 0x00)
 742               {
 743                 case 0x00:
 744                   goto op_semantics_6;
 745                   break;
 746               }
 747             break;
 748           case 0x17:
 749               GETBYTE ();
 750               switch (op[2] & 0x00)
 751               {
 752                 case 0x00:
 753                   goto op_semantics_6;
 754                   break;
 755               }
 756             break;
 757           case 0x20:
 758               GETBYTE ();
 759               switch (op[2] & 0xff)
 760               {
 761                 case 0x00:
 762                     GETBYTE ();
 763                     switch (op[3] & 0x00)
 764                     {
 765                       case 0x00:
 766                         op_semantics_7:
 767                           {
 768                             /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb     %1%S1, %0 */
 769 #line 535 "rx-decode.opc"
 770                             int mx AU = (op[1] >> 6) & 0x03;
 771 #line 535 "rx-decode.opc"
 772                             int sp AU = op[1] & 0x03;
 773 #line 535 "rx-decode.opc"
 774                             int rsrc AU = (op[3] >> 4) & 0x0f;
 775 #line 535 "rx-decode.opc"
 776                             int rdst AU = op[3] & 0x0f;
 777                             if (trace)
 778                               {
 779                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 780                                        "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst     sbb     %1%S1, %0 */",
 781                                        op[0], op[1], op[2], op[3]);
 782                                 printf ("  mx = 0x%x,", mx);
 783                                 printf ("  sp = 0x%x,", sp);
 784                                 printf ("  rsrc = 0x%x,", rsrc);
 785                                 printf ("  rdst = 0x%x\n", rdst);
 786                               }
 787                             SYNTAX("sbb %1%S1, %0");
 788 #line 535 "rx-decode.opc"
 789                             ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F("OSZC");
 790
 791                           /*----------------------------------------------------------------------*/
 792                           /* ABS                                                                        */
 793
 794                           }
 795                         break;
 796                     }
 797                   break;
 798                 case 0x04:
 799                     GETBYTE ();
 800                     switch (op[3] & 0x00)
 801                     {
 802                       case 0x00:
 803                         op_semantics_8:
 804                           {
 805                             /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max     %1%S1, %0 */
 806 #line 556 "rx-decode.opc"
 807                             int mx AU = (op[1] >> 6) & 0x03;
 808 #line 556 "rx-decode.opc"
 809                             int ss AU = op[1] & 0x03;
 810 #line 556 "rx-decode.opc"
 811                             int rsrc AU = (op[3] >> 4) & 0x0f;
 812 #line 556 "rx-decode.opc"
 813                             int rdst AU = op[3] & 0x0f;
 814                             if (trace)
 815                               {
 816                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 817                                        "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst     max     %1%S1, %0 */",
 818                                        op[0], op[1], op[2], op[3]);
 819                                 printf ("  mx = 0x%x,", mx);
 820                                 printf ("  ss = 0x%x,", ss);
 821                                 printf ("  rsrc = 0x%x,", rsrc);
 822                                 printf ("  rdst = 0x%x\n", rdst);
 823                               }
 824                             SYNTAX("max %1%S1, %0");
 825 #line 556 "rx-decode.opc"
 826                             ID(max); SPm(ss, rsrc, mx); DR(rdst);
 827
 828                           /*----------------------------------------------------------------------*/
 829                           /* MIN                                                                        */
 830
 831                           }
 832                         break;
 833                     }
 834                   break;
 835                 case 0x05:
 836                     GETBYTE ();
 837                     switch (op[3] & 0x00)
 838                     {
 839                       case 0x00:
 840                         op_semantics_9:
 841                           {
 842                             /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min     %1%S1, %0 */
 843 #line 568 "rx-decode.opc"
 844                             int mx AU = (op[1] >> 6) & 0x03;
 845 #line 568 "rx-decode.opc"
 846                             int ss AU = op[1] & 0x03;
 847 #line 568 "rx-decode.opc"
 848                             int rsrc AU = (op[3] >> 4) & 0x0f;
 849 #line 568 "rx-decode.opc"
 850                             int rdst AU = op[3] & 0x0f;
 851                             if (trace)
 852                               {
 853                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 854                                        "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst     min     %1%S1, %0 */",
 855                                        op[0], op[1], op[2], op[3]);
 856                                 printf ("  mx = 0x%x,", mx);
 857                                 printf ("  ss = 0x%x,", ss);
 858                                 printf ("  rsrc = 0x%x,", rsrc);
 859                                 printf ("  rdst = 0x%x\n", rdst);
 860                               }
 861                             SYNTAX("min %1%S1, %0");
 862 #line 568 "rx-decode.opc"
 863                             ID(min); SPm(ss, rsrc, mx); DR(rdst);
 864
 865                           /*----------------------------------------------------------------------*/
 866                           /* MUL                                                                        */
 867
 868                           }
 869                         break;
 870                     }
 871                   break;
 872                 case 0x06:
 873                     GETBYTE ();
 874                     switch (op[3] & 0x00)
 875                     {
 876                       case 0x00:
 877                         op_semantics_10:
 878                           {
 879                             /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul    %1%S1, %0 */
 880 #line 598 "rx-decode.opc"
 881                             int mx AU = (op[1] >> 6) & 0x03;
 882 #line 598 "rx-decode.opc"
 883                             int ss AU = op[1] & 0x03;
 884 #line 598 "rx-decode.opc"
 885                             int rsrc AU = (op[3] >> 4) & 0x0f;
 886 #line 598 "rx-decode.opc"
 887                             int rdst AU = op[3] & 0x0f;
 888                             if (trace)
 889                               {
 890                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 891                                        "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst     emul    %1%S1, %0 */",
 892                                        op[0], op[1], op[2], op[3]);
 893                                 printf ("  mx = 0x%x,", mx);
 894                                 printf ("  ss = 0x%x,", ss);
 895                                 printf ("  rsrc = 0x%x,", rsrc);
 896                                 printf ("  rdst = 0x%x\n", rdst);
 897                               }
 898                             SYNTAX("emul        %1%S1, %0");
 899 #line 598 "rx-decode.opc"
 900                             ID(emul); SPm(ss, rsrc, mx); DR(rdst);
 901
 902                           /*----------------------------------------------------------------------*/
 903                           /* EMULU                                                                      */
 904
 905                           }
 906                         break;
 907                     }
 908                   break;
 909                 case 0x07:
 910                     GETBYTE ();
 911                     switch (op[3] & 0x00)
 912                     {
 913                       case 0x00:
 914                         op_semantics_11:
 915                           {
 916                             /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu   %1%S1, %0 */
 917 #line 610 "rx-decode.opc"
 918                             int mx AU = (op[1] >> 6) & 0x03;
 919 #line 610 "rx-decode.opc"
 920                             int ss AU = op[1] & 0x03;
 921 #line 610 "rx-decode.opc"
 922                             int rsrc AU = (op[3] >> 4) & 0x0f;
 923 #line 610 "rx-decode.opc"
 924                             int rdst AU = op[3] & 0x0f;
 925                             if (trace)
 926                               {
 927                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 928                                        "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst     emulu   %1%S1, %0 */",
 929                                        op[0], op[1], op[2], op[3]);
 930                                 printf ("  mx = 0x%x,", mx);
 931                                 printf ("  ss = 0x%x,", ss);
 932                                 printf ("  rsrc = 0x%x,", rsrc);
 933                                 printf ("  rdst = 0x%x\n", rdst);
 934                               }
 935                             SYNTAX("emulu       %1%S1, %0");
 936 #line 610 "rx-decode.opc"
 937                             ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
 938
 939                           /*----------------------------------------------------------------------*/
 940                           /* DIV                                                                        */
 941
 942                           }
 943                         break;
 944                     }
 945                   break;
 946                 case 0x08:
 947                     GETBYTE ();
 948                     switch (op[3] & 0x00)
 949                     {
 950                       case 0x00:
 951                         op_semantics_12:
 952                           {
 953                             /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div     %1%S1, %0 */
 954 #line 622 "rx-decode.opc"
 955                             int mx AU = (op[1] >> 6) & 0x03;
 956 #line 622 "rx-decode.opc"
 957                             int ss AU = op[1] & 0x03;
 958 #line 622 "rx-decode.opc"
 959                             int rsrc AU = (op[3] >> 4) & 0x0f;
 960 #line 622 "rx-decode.opc"
 961                             int rdst AU = op[3] & 0x0f;
 962                             if (trace)
 963                               {
 964                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 965                                        "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst     div     %1%S1, %0 */",
 966                                        op[0], op[1], op[2], op[3]);
 967                                 printf ("  mx = 0x%x,", mx);
 968                                 printf ("  ss = 0x%x,", ss);
 969                                 printf ("  rsrc = 0x%x,", rsrc);
 970                                 printf ("  rdst = 0x%x\n", rdst);
 971                               }
 972                             SYNTAX("div %1%S1, %0");
 973 #line 622 "rx-decode.opc"
 974                             ID(div); SPm(ss, rsrc, mx); DR(rdst); F("O---");
 975
 976                           /*----------------------------------------------------------------------*/
 977                           /* DIVU                                                                       */
 978
 979                           }
 980                         break;
 981                     }
 982                   break;
 983                 case 0x09:
 984                     GETBYTE ();
 985                     switch (op[3] & 0x00)
 986                     {
 987                       case 0x00:
 988                         op_semantics_13:
 989                           {
 990                             /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu    %1%S1, %0 */
 991 #line 634 "rx-decode.opc"
 992                             int mx AU = (op[1] >> 6) & 0x03;
 993 #line 634 "rx-decode.opc"
 994                             int ss AU = op[1] & 0x03;
 995 #line 634 "rx-decode.opc"
 996                             int rsrc AU = (op[3] >> 4) & 0x0f;
 997 #line 634 "rx-decode.opc"
 998                             int rdst AU = op[3] & 0x0f;
 999                             if (trace)
1000                               {
1001                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1002                                        "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst     divu    %1%S1, %0 */",
1003                                        op[0], op[1], op[2], op[3]);
1004                                 printf ("  mx = 0x%x,", mx);
1005                                 printf ("  ss = 0x%x,", ss);
1006                                 printf ("  rsrc = 0x%x,", rsrc);
1007                                 printf ("  rdst = 0x%x\n", rdst);
1008                               }
1009                             SYNTAX("divu        %1%S1, %0");
1010 #line 634 "rx-decode.opc"
1011                             ID(divu); SPm(ss, rsrc, mx); DR(rdst); F("O---");
1012
1013                           /*----------------------------------------------------------------------*/
1014                           /* SHIFT                                                              */
1015
1016                           }
1017                         break;
1018                     }
1019                   break;
1020                 case 0x0c:
1021                     GETBYTE ();
1022                     switch (op[3] & 0x00)
1023                     {
1024                       case 0x00:
1025                         op_semantics_14:
1026                           {
1027                             /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst     %1%S1, %2 */
1028 #line 453 "rx-decode.opc"
1029                             int mx AU = (op[1] >> 6) & 0x03;
1030 #line 453 "rx-decode.opc"
1031                             int ss AU = op[1] & 0x03;
1032 #line 453 "rx-decode.opc"
1033                             int rsrc AU = (op[3] >> 4) & 0x0f;
1034 #line 453 "rx-decode.opc"
1035                             int rdst AU = op[3] & 0x0f;
1036                             if (trace)
1037                               {
1038                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1039                                        "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst     tst     %1%S1, %2 */",
1040                                        op[0], op[1], op[2], op[3]);
1041                                 printf ("  mx = 0x%x,", mx);
1042                                 printf ("  ss = 0x%x,", ss);
1043                                 printf ("  rsrc = 0x%x,", rsrc);
1044                                 printf ("  rdst = 0x%x\n", rdst);
1045                               }
1046                             SYNTAX("tst %1%S1, %2");
1047 #line 453 "rx-decode.opc"
1048                             ID(and); SPm(ss, rsrc, mx); S2R(rdst); F("-SZ-");
1049
1050                           /*----------------------------------------------------------------------*/
1051                           /* NEG                                                                        */
1052
1053                           }
1054                         break;
1055                     }
1056                   break;
1057                 case 0x0d:
1058                     GETBYTE ();
1059                     switch (op[3] & 0x00)
1060                     {
1061                       case 0x00:
1062                         op_semantics_15:
1063                           {
1064                             /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor     %1%S1, %0 */
1065 #line 432 "rx-decode.opc"
1066                             int mx AU = (op[1] >> 6) & 0x03;
1067 #line 432 "rx-decode.opc"
1068                             int ss AU = op[1] & 0x03;
1069 #line 432 "rx-decode.opc"
1070                             int rsrc AU = (op[3] >> 4) & 0x0f;
1071 #line 432 "rx-decode.opc"
1072                             int rdst AU = op[3] & 0x0f;
1073                             if (trace)
1074                               {
1075                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1076                                        "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst     xor     %1%S1, %0 */",
1077                                        op[0], op[1], op[2], op[3]);
1078                                 printf ("  mx = 0x%x,", mx);
1079                                 printf ("  ss = 0x%x,", ss);
1080                                 printf ("  rsrc = 0x%x,", rsrc);
1081                                 printf ("  rdst = 0x%x\n", rdst);
1082                               }
1083                             SYNTAX("xor %1%S1, %0");
1084 #line 432 "rx-decode.opc"
1085                             ID(xor); SPm(ss, rsrc, mx); DR(rdst); F("-SZ-");
1086
1087                           /*----------------------------------------------------------------------*/
1088                           /* NOT                                                                        */
1089
1090                           }
1091                         break;
1092                     }
1093                   break;
1094                 case 0x10:
1095                     GETBYTE ();
1096                     switch (op[3] & 0x00)
1097                     {
1098                       case 0x00:
1099                         op_semantics_16:
1100                           {
1101                             /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg    %1%S1, %0 */
1102 #line 366 "rx-decode.opc"
1103                             int mx AU = (op[1] >> 6) & 0x03;
1104 #line 366 "rx-decode.opc"
1105                             int ss AU = op[1] & 0x03;
1106 #line 366 "rx-decode.opc"
1107                             int rsrc AU = (op[3] >> 4) & 0x0f;
1108 #line 366 "rx-decode.opc"
1109                             int rdst AU = op[3] & 0x0f;
1110                             if (trace)
1111                               {
1112                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1113                                        "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst     xchg    %1%S1, %0 */",
1114                                        op[0], op[1], op[2], op[3]);
1115                                 printf ("  mx = 0x%x,", mx);
1116                                 printf ("  ss = 0x%x,", ss);
1117                                 printf ("  rsrc = 0x%x,", rsrc);
1118                                 printf ("  rdst = 0x%x\n", rdst);
1119                               }
1120                             SYNTAX("xchg        %1%S1, %0");
1121 #line 366 "rx-decode.opc"
1122                             ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1123
1124                           /*----------------------------------------------------------------------*/
1125                           /* STZ/STNZ                                                           */
1126
1127                           }
1128                         break;
1129                     }
1130                   break;
1131                 case 0x11:
1132                     GETBYTE ();
1133                     switch (op[3] & 0x00)
1134                     {
1135                       case 0x00:
1136                         op_semantics_17:
1137                           {
1138                             /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof    %1%S1, %0 */
1139 #line 863 "rx-decode.opc"
1140                             int mx AU = (op[1] >> 6) & 0x03;
1141 #line 863 "rx-decode.opc"
1142                             int sd AU = op[1] & 0x03;
1143 #line 863 "rx-decode.opc"
1144                             int rsrc AU = (op[3] >> 4) & 0x0f;
1145 #line 863 "rx-decode.opc"
1146                             int rdst AU = op[3] & 0x0f;
1147                             if (trace)
1148                               {
1149                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1150                                        "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst     itof    %1%S1, %0 */",
1151                                        op[0], op[1], op[2], op[3]);
1152                                 printf ("  mx = 0x%x,", mx);
1153                                 printf ("  sd = 0x%x,", sd);
1154                                 printf ("  rsrc = 0x%x,", rsrc);
1155                                 printf ("  rdst = 0x%x\n", rdst);
1156                               }
1157                             SYNTAX("itof        %1%S1, %0");
1158 #line 863 "rx-decode.opc"
1159                             ID(itof); DR (rdst); SPm(sd, rsrc, mx); F("-SZ-");
1160
1161                           /*----------------------------------------------------------------------*/
1162                           /* BIT OPS                                                            */
1163
1164                           }
1165                         break;
1166                     }
1167                   break;
1168                 default: UNSUPPORTED(); break;
1169               }
1170             break;
1171           case 0x21:
1172               GETBYTE ();
1173               switch (op[2] & 0xff)
1174               {
1175                 case 0x00:
1176                     GETBYTE ();
1177                     switch (op[3] & 0x00)
1178                     {
1179                       case 0x00:
1180                         goto op_semantics_7;
1181                         break;
1182                     }
1183                   break;
1184                 case 0x04:
1185                     GETBYTE ();
1186                     switch (op[3] & 0x00)
1187                     {
1188                       case 0x00:
1189                         goto op_semantics_8;
1190                         break;
1191                     }
1192                   break;
1193                 case 0x05:
1194                     GETBYTE ();
1195                     switch (op[3] & 0x00)
1196                     {
1197                       case 0x00:
1198                         goto op_semantics_9;
1199                         break;
1200                     }
1201                   break;
1202                 case 0x06:
1203                     GETBYTE ();
1204                     switch (op[3] & 0x00)
1205                     {
1206                       case 0x00:
1207                         goto op_semantics_10;
1208                         break;
1209                     }
1210                   break;
1211                 case 0x07:
1212                     GETBYTE ();
1213                     switch (op[3] & 0x00)
1214                     {
1215                       case 0x00:
1216                         goto op_semantics_11;
1217                         break;
1218                     }
1219                   break;
1220                 case 0x08:
1221                     GETBYTE ();
1222                     switch (op[3] & 0x00)
1223                     {
1224                       case 0x00:
1225                         goto op_semantics_12;
1226                         break;
1227                     }
1228                   break;
1229                 case 0x09:
1230                     GETBYTE ();
1231                     switch (op[3] & 0x00)
1232                     {
1233                       case 0x00:
1234                         goto op_semantics_13;
1235                         break;
1236                     }
1237                   break;
1238                 case 0x0c:
1239                     GETBYTE ();
1240                     switch (op[3] & 0x00)
1241                     {
1242                       case 0x00:
1243                         goto op_semantics_14;
1244                         break;
1245                     }
1246                   break;
1247                 case 0x0d:
1248                     GETBYTE ();
1249                     switch (op[3] & 0x00)
1250                     {
1251                       case 0x00:
1252                         goto op_semantics_15;
1253                         break;
1254                     }
1255                   break;
1256                 case 0x10:
1257                     GETBYTE ();
1258                     switch (op[3] & 0x00)
1259                     {
1260                       case 0x00:
1261                         goto op_semantics_16;
1262                         break;
1263                     }
1264                   break;
1265                 case 0x11:
1266                     GETBYTE ();
1267                     switch (op[3] & 0x00)
1268                     {
1269                       case 0x00:
1270                         goto op_semantics_17;
1271                         break;
1272                     }
1273                   break;
1274                 default: UNSUPPORTED(); break;
1275               }
1276             break;
1277           case 0x22:
1278               GETBYTE ();
1279               switch (op[2] & 0xff)
1280               {
1281                 case 0x00:
1282                     GETBYTE ();
1283                     switch (op[3] & 0x00)
1284                     {
1285                       case 0x00:
1286                         goto op_semantics_7;
1287                         break;
1288                     }
1289                   break;
1290                 case 0x04:
1291                     GETBYTE ();
1292                     switch (op[3] & 0x00)
1293                     {
1294                       case 0x00:
1295                         goto op_semantics_8;
1296                         break;
1297                     }
1298                   break;
1299                 case 0x05:
1300                     GETBYTE ();
1301                     switch (op[3] & 0x00)
1302                     {
1303                       case 0x00:
1304                         goto op_semantics_9;
1305                         break;
1306                     }
1307                   break;
1308                 case 0x06:
1309                     GETBYTE ();
1310                     switch (op[3] & 0x00)
1311                     {
1312                       case 0x00:
1313                         goto op_semantics_10;
1314                         break;
1315                     }
1316                   break;
1317                 case 0x07:
1318                     GETBYTE ();
1319                     switch (op[3] & 0x00)
1320                     {
1321                       case 0x00:
1322                         goto op_semantics_11;
1323                         break;
1324                     }
1325                   break;
1326                 case 0x08:
1327                     GETBYTE ();
1328                     switch (op[3] & 0x00)
1329                     {
1330                       case 0x00:
1331                         goto op_semantics_12;
1332                         break;
1333                     }
1334                   break;
1335                 case 0x09:
1336                     GETBYTE ();
1337                     switch (op[3] & 0x00)
1338                     {
1339                       case 0x00:
1340                         goto op_semantics_13;
1341                         break;
1342                     }
1343                   break;
1344                 case 0x0c:
1345                     GETBYTE ();
1346                     switch (op[3] & 0x00)
1347                     {
1348                       case 0x00:
1349                         goto op_semantics_14;
1350                         break;
1351                     }
1352                   break;
1353                 case 0x0d:
1354                     GETBYTE ();
1355                     switch (op[3] & 0x00)
1356                     {
1357                       case 0x00:
1358                         goto op_semantics_15;
1359                         break;
1360                     }
1361                   break;
1362                 case 0x10:
1363                     GETBYTE ();
1364                     switch (op[3] & 0x00)
1365                     {
1366                       case 0x00:
1367                         goto op_semantics_16;
1368                         break;
1369                     }
1370                   break;
1371                 case 0x11:
1372                     GETBYTE ();
1373                     switch (op[3] & 0x00)
1374                     {
1375                       case 0x00:
1376                         goto op_semantics_17;
1377                         break;
1378                     }
1379                   break;
1380                 default: UNSUPPORTED(); break;
1381               }
1382             break;
1383           case 0x23:
1384               GETBYTE ();
1385               switch (op[2] & 0xff)
1386               {
1387                 case 0x00:
1388                     GETBYTE ();
1389                     switch (op[3] & 0x00)
1390                     {
1391                       case 0x00:
1392                         goto op_semantics_7;
1393                         break;
1394                     }
1395                   break;
1396                 case 0x04:
1397                     GETBYTE ();
1398                     switch (op[3] & 0x00)
1399                     {
1400                       case 0x00:
1401                         goto op_semantics_8;
1402                         break;
1403                     }
1404                   break;
1405                 case 0x05:
1406                     GETBYTE ();
1407                     switch (op[3] & 0x00)
1408                     {
1409                       case 0x00:
1410                         goto op_semantics_9;
1411                         break;
1412                     }
1413                   break;
1414                 case 0x06:
1415                     GETBYTE ();
1416                     switch (op[3] & 0x00)
1417                     {
1418                       case 0x00:
1419                         goto op_semantics_10;
1420                         break;
1421                     }
1422                   break;
1423                 case 0x07:
1424                     GETBYTE ();
1425                     switch (op[3] & 0x00)
1426                     {
1427                       case 0x00:
1428                         goto op_semantics_11;
1429                         break;
1430                     }
1431                   break;
1432                 case 0x08:
1433                     GETBYTE ();
1434                     switch (op[3] & 0x00)
1435                     {
1436                       case 0x00:
1437                         goto op_semantics_12;
1438                         break;
1439                     }
1440                   break;
1441                 case 0x09:
1442                     GETBYTE ();
1443                     switch (op[3] & 0x00)
1444                     {
1445                       case 0x00:
1446                         goto op_semantics_13;
1447                         break;
1448                     }
1449                   break;
1450                 case 0x0c:
1451                     GETBYTE ();
1452                     switch (op[3] & 0x00)
1453                     {
1454                       case 0x00:
1455                         goto op_semantics_14;
1456                         break;
1457                     }
1458                   break;
1459                 case 0x0d:
1460                     GETBYTE ();
1461                     switch (op[3] & 0x00)
1462                     {
1463                       case 0x00:
1464                         goto op_semantics_15;
1465                         break;
1466                     }
1467                   break;
1468                 case 0x10:
1469                     GETBYTE ();
1470                     switch (op[3] & 0x00)
1471                     {
1472                       case 0x00:
1473                         goto op_semantics_16;
1474                         break;
1475                     }
1476                   break;
1477                 case 0x11:
1478                     GETBYTE ();
1479                     switch (op[3] & 0x00)
1480                     {
1481                       case 0x00:
1482                         goto op_semantics_17;
1483                         break;
1484                     }
1485                   break;
1486                 default: UNSUPPORTED(); break;
1487               }
1488             break;
1489           case 0x40:
1490               GETBYTE ();
1491               switch (op[2] & 0x00)
1492               {
1493                 case 0x00:
1494                   goto op_semantics_1;
1495                   break;
1496               }
1497             break;
1498           case 0x41:
1499               GETBYTE ();
1500               switch (op[2] & 0x00)
1501               {
1502                 case 0x00:
1503                   goto op_semantics_1;
1504                   break;
1505               }
1506             break;
1507           case 0x42:
1508               GETBYTE ();
1509               switch (op[2] & 0x00)
1510               {
1511                 case 0x00:
1512                   goto op_semantics_1;
1513                   break;
1514               }
1515             break;
1516           case 0x43:
1517               GETBYTE ();
1518               switch (op[2] & 0x00)
1519               {
1520                 case 0x00:
1521                   goto op_semantics_1;
1522                   break;
1523               }
1524             break;
1525           case 0x44:
1526               GETBYTE ();
1527               switch (op[2] & 0x00)
1528               {
1529                 case 0x00:
1530                   goto op_semantics_2;
1531                   break;
1532               }
1533             break;
1534           case 0x45:
1535               GETBYTE ();
1536               switch (op[2] & 0x00)
1537               {
1538                 case 0x00:
1539                   goto op_semantics_2;
1540                   break;
1541               }
1542             break;
1543           case 0x46:
1544               GETBYTE ();
1545               switch (op[2] & 0x00)
1546               {
1547                 case 0x00:
1548                   goto op_semantics_2;
1549                   break;
1550               }
1551             break;
1552           case 0x47:
1553               GETBYTE ();
1554               switch (op[2] & 0x00)
1555               {
1556                 case 0x00:
1557                   goto op_semantics_2;
1558                   break;
1559               }
1560             break;
1561           case 0x48:
1562               GETBYTE ();
1563               switch (op[2] & 0x00)
1564               {
1565                 case 0x00:
1566                   goto op_semantics_3;
1567                   break;
1568               }
1569             break;
1570           case 0x49:
1571               GETBYTE ();
1572               switch (op[2] & 0x00)
1573               {
1574                 case 0x00:
1575                   goto op_semantics_3;
1576                   break;
1577               }
1578             break;
1579           case 0x4a:
1580               GETBYTE ();
1581               switch (op[2] & 0x00)
1582               {
1583                 case 0x00:
1584                   goto op_semantics_3;
1585                   break;
1586               }
1587             break;
1588           case 0x4b:
1589               GETBYTE ();
1590               switch (op[2] & 0x00)
1591               {
1592                 case 0x00:
1593                   goto op_semantics_3;
1594                   break;
1595               }
1596             break;
1597           case 0x4c:
1598               GETBYTE ();
1599               switch (op[2] & 0x00)
1600               {
1601                 case 0x00:
1602                   goto op_semantics_4;
1603                   break;
1604               }
1605             break;
1606           case 0x4d:
1607               GETBYTE ();
1608               switch (op[2] & 0x00)
1609               {
1610                 case 0x00:
1611                   goto op_semantics_4;
1612                   break;
1613               }
1614             break;
1615           case 0x4e:
1616               GETBYTE ();
1617               switch (op[2] & 0x00)
1618               {
1619                 case 0x00:
1620                   goto op_semantics_4;
1621                   break;
1622               }
1623             break;
1624           case 0x4f:
1625               GETBYTE ();
1626               switch (op[2] & 0x00)
1627               {
1628                 case 0x00:
1629                   goto op_semantics_4;
1630                   break;
1631               }
1632             break;
1633           case 0x50:
1634               GETBYTE ();
1635               switch (op[2] & 0x00)
1636               {
1637                 case 0x00:
1638                   goto op_semantics_5;
1639                   break;
1640               }
1641             break;
1642           case 0x51:
1643               GETBYTE ();
1644               switch (op[2] & 0x00)
1645               {
1646                 case 0x00:
1647                   goto op_semantics_5;
1648                   break;
1649               }
1650             break;
1651           case 0x52:
1652               GETBYTE ();
1653               switch (op[2] & 0x00)
1654               {
1655                 case 0x00:
1656                   goto op_semantics_5;
1657                   break;
1658               }
1659             break;
1660           case 0x53:
1661               GETBYTE ();
1662               switch (op[2] & 0x00)
1663               {
1664                 case 0x00:
1665                   goto op_semantics_5;
1666                   break;
1667               }
1668             break;
1669           case 0x54:
1670               GETBYTE ();
1671               switch (op[2] & 0x00)
1672               {
1673                 case 0x00:
1674                   goto op_semantics_6;
1675                   break;
1676               }
1677             break;
1678           case 0x55:
1679               GETBYTE ();
1680               switch (op[2] & 0x00)
1681               {
1682                 case 0x00:
1683                   goto op_semantics_6;
1684                   break;
1685               }
1686             break;
1687           case 0x56:
1688               GETBYTE ();
1689               switch (op[2] & 0x00)
1690               {
1691                 case 0x00:
1692                   goto op_semantics_6;
1693                   break;
1694               }
1695             break;
1696           case 0x57:
1697               GETBYTE ();
1698               switch (op[2] & 0x00)
1699               {
1700                 case 0x00:
1701                   goto op_semantics_6;
1702                   break;
1703               }
1704             break;
1705           case 0x60:
1706               GETBYTE ();
1707               switch (op[2] & 0xff)
1708               {
1709                 case 0x00:
1710                     GETBYTE ();
1711                     switch (op[3] & 0x00)
1712                     {
1713                       case 0x00:
1714                         goto op_semantics_7;
1715                         break;
1716                     }
1717                   break;
1718                 case 0x04:
1719                     GETBYTE ();
1720                     switch (op[3] & 0x00)
1721                     {
1722                       case 0x00:
1723                         goto op_semantics_8;
1724                         break;
1725                     }
1726                   break;
1727                 case 0x05:
1728                     GETBYTE ();
1729                     switch (op[3] & 0x00)
1730                     {
1731                       case 0x00:
1732                         goto op_semantics_9;
1733                         break;
1734                     }
1735                   break;
1736                 case 0x06:
1737                     GETBYTE ();
1738                     switch (op[3] & 0x00)
1739                     {
1740                       case 0x00:
1741                         goto op_semantics_10;
1742                         break;
1743                     }
1744                   break;
1745                 case 0x07:
1746                     GETBYTE ();
1747                     switch (op[3] & 0x00)
1748                     {
1749                       case 0x00:
1750                         goto op_semantics_11;
1751                         break;
1752                     }
1753                   break;
1754                 case 0x08:
1755                     GETBYTE ();
1756                     switch (op[3] & 0x00)
1757                     {
1758                       case 0x00:
1759                         goto op_semantics_12;
1760                         break;
1761                     }
1762                   break;
1763                 case 0x09:
1764                     GETBYTE ();
1765                     switch (op[3] & 0x00)
1766                     {
1767                       case 0x00:
1768                         goto op_semantics_13;
1769                         break;
1770                     }
1771                   break;
1772                 case 0x0c:
1773                     GETBYTE ();
1774                     switch (op[3] & 0x00)
1775                     {
1776                       case 0x00:
1777                         goto op_semantics_14;
1778                         break;
1779                     }
1780                   break;
1781                 case 0x0d:
1782                     GETBYTE ();
1783                     switch (op[3] & 0x00)
1784                     {
1785                       case 0x00:
1786                         goto op_semantics_15;
1787                         break;
1788                     }
1789                   break;
1790                 case 0x10:
1791                     GETBYTE ();
1792                     switch (op[3] & 0x00)
1793                     {
1794                       case 0x00:
1795                         goto op_semantics_16;
1796                         break;
1797                     }
1798                   break;
1799                 case 0x11:
1800                     GETBYTE ();
1801                     switch (op[3] & 0x00)
1802                     {
1803                       case 0x00:
1804                         goto op_semantics_17;
1805                         break;
1806                     }
1807                   break;
1808                 default: UNSUPPORTED(); break;
1809               }
1810             break;
1811           case 0x61:
1812               GETBYTE ();
1813               switch (op[2] & 0xff)
1814               {
1815                 case 0x00:
1816                     GETBYTE ();
1817                     switch (op[3] & 0x00)
1818                     {
1819                       case 0x00:
1820                         goto op_semantics_7;
1821                         break;
1822                     }
1823                   break;
1824                 case 0x04:
1825                     GETBYTE ();
1826                     switch (op[3] & 0x00)
1827                     {
1828                       case 0x00:
1829                         goto op_semantics_8;
1830                         break;
1831                     }
1832                   break;
1833                 case 0x05:
1834                     GETBYTE ();
1835                     switch (op[3] & 0x00)
1836                     {
1837                       case 0x00:
1838                         goto op_semantics_9;
1839                         break;
1840                     }
1841                   break;
1842                 case 0x06:
1843                     GETBYTE ();
1844                     switch (op[3] & 0x00)
1845                     {
1846                       case 0x00:
1847                         goto op_semantics_10;
1848                         break;
1849                     }
1850                   break;
1851                 case 0x07:
1852                     GETBYTE ();
1853                     switch (op[3] & 0x00)
1854                     {
1855                       case 0x00:
1856                         goto op_semantics_11;
1857                         break;
1858                     }
1859                   break;
1860                 case 0x08:
1861                     GETBYTE ();
1862                     switch (op[3] & 0x00)
1863                     {
1864                       case 0x00:
1865                         goto op_semantics_12;
1866                         break;
1867                     }
1868                   break;
1869                 case 0x09:
1870                     GETBYTE ();
1871                     switch (op[3] & 0x00)
1872                     {
1873                       case 0x00:
1874                         goto op_semantics_13;
1875                         break;
1876                     }
1877                   break;
1878                 case 0x0c:
1879                     GETBYTE ();
1880                     switch (op[3] & 0x00)
1881                     {
1882                       case 0x00:
1883                         goto op_semantics_14;
1884                         break;
1885                     }
1886                   break;
1887                 case 0x0d:
1888                     GETBYTE ();
1889                     switch (op[3] & 0x00)
1890                     {
1891                       case 0x00:
1892                         goto op_semantics_15;
1893                         break;
1894                     }
1895                   break;
1896                 case 0x10:
1897                     GETBYTE ();
1898                     switch (op[3] & 0x00)
1899                     {
1900                       case 0x00:
1901                         goto op_semantics_16;
1902                         break;
1903                     }
1904                   break;
1905                 case 0x11:
1906                     GETBYTE ();
1907                     switch (op[3] & 0x00)
1908                     {
1909                       case 0x00:
1910                         goto op_semantics_17;
1911                         break;
1912                     }
1913                   break;
1914                 default: UNSUPPORTED(); break;
1915               }
1916             break;
1917           case 0x62:
1918               GETBYTE ();
1919               switch (op[2] & 0xff)
1920               {
1921                 case 0x00:
1922                     GETBYTE ();
1923                     switch (op[3] & 0x00)
1924                     {
1925                       case 0x00:
1926                         goto op_semantics_7;
1927                         break;
1928                     }
1929                   break;
1930                 case 0x04:
1931                     GETBYTE ();
1932                     switch (op[3] & 0x00)
1933                     {
1934                       case 0x00:
1935                         goto op_semantics_8;
1936                         break;
1937                     }
1938                   break;
1939                 case 0x05:
1940                     GETBYTE ();
1941                     switch (op[3] & 0x00)
1942                     {
1943                       case 0x00:
1944                         goto op_semantics_9;
1945                         break;
1946                     }
1947                   break;
1948                 case 0x06:
1949                     GETBYTE ();
1950                     switch (op[3] & 0x00)
1951                     {
1952                       case 0x00:
1953                         goto op_semantics_10;
1954                         break;
1955                     }
1956                   break;
1957                 case 0x07:
1958                     GETBYTE ();
1959                     switch (op[3] & 0x00)
1960                     {
1961                       case 0x00:
1962                         goto op_semantics_11;
1963                         break;
1964                     }
1965                   break;
1966                 case 0x08:
1967                     GETBYTE ();
1968                     switch (op[3] & 0x00)
1969                     {
1970                       case 0x00:
1971                         goto op_semantics_12;
1972                         break;
1973                     }
1974                   break;
1975                 case 0x09:
1976                     GETBYTE ();
1977                     switch (op[3] & 0x00)
1978                     {
1979                       case 0x00:
1980                         goto op_semantics_13;
1981                         break;
1982                     }
1983                   break;
1984                 case 0x0c:
1985                     GETBYTE ();
1986                     switch (op[3] & 0x00)
1987                     {
1988                       case 0x00:
1989                         goto op_semantics_14;
1990                         break;
1991                     }
1992                   break;
1993                 case 0x0d:
1994                     GETBYTE ();
1995                     switch (op[3] & 0x00)
1996                     {
1997                       case 0x00:
1998                         goto op_semantics_15;
1999                         break;
2000                     }
2001                   break;
2002                 case 0x10:
2003                     GETBYTE ();
2004                     switch (op[3] & 0x00)
2005                     {
2006                       case 0x00:
2007                         goto op_semantics_16;
2008                         break;
2009                     }
2010                   break;
2011                 case 0x11:
2012                     GETBYTE ();
2013                     switch (op[3] & 0x00)
2014                     {
2015                       case 0x00:
2016                         goto op_semantics_17;
2017                         break;
2018                     }
2019                   break;
2020                 default: UNSUPPORTED(); break;
2021               }
2022             break;
2023           case 0x63:
2024               GETBYTE ();
2025               switch (op[2] & 0xff)
2026               {
2027                 case 0x00:
2028                     GETBYTE ();
2029                     switch (op[3] & 0x00)
2030                     {
2031                       case 0x00:
2032                         goto op_semantics_7;
2033                         break;
2034                     }
2035                   break;
2036                 case 0x04:
2037                     GETBYTE ();
2038                     switch (op[3] & 0x00)
2039                     {
2040                       case 0x00:
2041                         goto op_semantics_8;
2042                         break;
2043                     }
2044                   break;
2045                 case 0x05:
2046                     GETBYTE ();
2047                     switch (op[3] & 0x00)
2048                     {
2049                       case 0x00:
2050                         goto op_semantics_9;
2051                         break;
2052                     }
2053                   break;
2054                 case 0x06:
2055                     GETBYTE ();
2056                     switch (op[3] & 0x00)
2057                     {
2058                       case 0x00:
2059                         goto op_semantics_10;
2060                         break;
2061                     }
2062                   break;
2063                 case 0x07:
2064                     GETBYTE ();
2065                     switch (op[3] & 0x00)
2066                     {
2067                       case 0x00:
2068                         goto op_semantics_11;
2069                         break;
2070                     }
2071                   break;
2072                 case 0x08:
2073                     GETBYTE ();
2074                     switch (op[3] & 0x00)
2075                     {
2076                       case 0x00:
2077                         goto op_semantics_12;
2078                         break;
2079                     }
2080                   break;
2081                 case 0x09:
2082                     GETBYTE ();
2083                     switch (op[3] & 0x00)
2084                     {
2085                       case 0x00:
2086                         goto op_semantics_13;
2087                         break;
2088                     }
2089                   break;
2090                 case 0x0c:
2091                     GETBYTE ();
2092                     switch (op[3] & 0x00)
2093                     {
2094                       case 0x00:
2095                         goto op_semantics_14;
2096                         break;
2097                     }
2098                   break;
2099                 case 0x0d:
2100                     GETBYTE ();
2101                     switch (op[3] & 0x00)
2102                     {
2103                       case 0x00:
2104                         goto op_semantics_15;
2105                         break;
2106                     }
2107                   break;
2108                 case 0x10:
2109                     GETBYTE ();
2110                     switch (op[3] & 0x00)
2111                     {
2112                       case 0x00:
2113                         goto op_semantics_16;
2114                         break;
2115                     }
2116                   break;
2117                 case 0x11:
2118                     GETBYTE ();
2119                     switch (op[3] & 0x00)
2120                     {
2121                       case 0x00:
2122                         goto op_semantics_17;
2123                         break;
2124                     }
2125                   break;
2126                 default: UNSUPPORTED(); break;
2127               }
2128             break;
2129           case 0x80:
2130               GETBYTE ();
2131               switch (op[2] & 0x00)
2132               {
2133                 case 0x00:
2134                   goto op_semantics_1;
2135                   break;
2136               }
2137             break;
2138           case 0x81:
2139               GETBYTE ();
2140               switch (op[2] & 0x00)
2141               {
2142                 case 0x00:
2143                   goto op_semantics_1;
2144                   break;
2145               }
2146             break;
2147           case 0x82:
2148               GETBYTE ();
2149               switch (op[2] & 0x00)
2150               {
2151                 case 0x00:
2152                   goto op_semantics_1;
2153                   break;
2154               }
2155             break;
2156           case 0x83:
2157               GETBYTE ();
2158               switch (op[2] & 0x00)
2159               {
2160                 case 0x00:
2161                   goto op_semantics_1;
2162                   break;
2163               }
2164             break;
2165           case 0x84:
2166               GETBYTE ();
2167               switch (op[2] & 0x00)
2168               {
2169                 case 0x00:
2170                   goto op_semantics_2;
2171                   break;
2172               }
2173             break;
2174           case 0x85:
2175               GETBYTE ();
2176               switch (op[2] & 0x00)
2177               {
2178                 case 0x00:
2179                   goto op_semantics_2;
2180                   break;
2181               }
2182             break;
2183           case 0x86:
2184               GETBYTE ();
2185               switch (op[2] & 0x00)
2186               {
2187                 case 0x00:
2188                   goto op_semantics_2;
2189                   break;
2190               }
2191             break;
2192           case 0x87:
2193               GETBYTE ();
2194               switch (op[2] & 0x00)
2195               {
2196                 case 0x00:
2197                   goto op_semantics_2;
2198                   break;
2199               }
2200             break;
2201           case 0x88:
2202               GETBYTE ();
2203               switch (op[2] & 0x00)
2204               {
2205                 case 0x00:
2206                   goto op_semantics_3;
2207                   break;
2208               }
2209             break;
2210           case 0x89:
2211               GETBYTE ();
2212               switch (op[2] & 0x00)
2213               {
2214                 case 0x00:
2215                   goto op_semantics_3;
2216                   break;
2217               }
2218             break;
2219           case 0x8a:
2220               GETBYTE ();
2221               switch (op[2] & 0x00)
2222               {
2223                 case 0x00:
2224                   goto op_semantics_3;
2225                   break;
2226               }
2227             break;
2228           case 0x8b:
2229               GETBYTE ();
2230               switch (op[2] & 0x00)
2231               {
2232                 case 0x00:
2233                   goto op_semantics_3;
2234                   break;
2235               }
2236             break;
2237           case 0x8c:
2238               GETBYTE ();
2239               switch (op[2] & 0x00)
2240               {
2241                 case 0x00:
2242                   goto op_semantics_4;
2243                   break;
2244               }
2245             break;
2246           case 0x8d:
2247               GETBYTE ();
2248               switch (op[2] & 0x00)
2249               {
2250                 case 0x00:
2251                   goto op_semantics_4;
2252                   break;
2253               }
2254             break;
2255           case 0x8e:
2256               GETBYTE ();
2257               switch (op[2] & 0x00)
2258               {
2259                 case 0x00:
2260                   goto op_semantics_4;
2261                   break;
2262               }
2263             break;
2264           case 0x8f:
2265               GETBYTE ();
2266               switch (op[2] & 0x00)
2267               {
2268                 case 0x00:
2269                   goto op_semantics_4;
2270                   break;
2271               }
2272             break;
2273           case 0x90:
2274               GETBYTE ();
2275               switch (op[2] & 0x00)
2276               {
2277                 case 0x00:
2278                   goto op_semantics_5;
2279                   break;
2280               }
2281             break;
2282           case 0x91:
2283               GETBYTE ();
2284               switch (op[2] & 0x00)
2285               {
2286                 case 0x00:
2287                   goto op_semantics_5;
2288                   break;
2289               }
2290             break;
2291           case 0x92:
2292               GETBYTE ();
2293               switch (op[2] & 0x00)
2294               {
2295                 case 0x00:
2296                   goto op_semantics_5;
2297                   break;
2298               }
2299             break;
2300           case 0x93:
2301               GETBYTE ();
2302               switch (op[2] & 0x00)
2303               {
2304                 case 0x00:
2305                   goto op_semantics_5;
2306                   break;
2307               }
2308             break;
2309           case 0x94:
2310               GETBYTE ();
2311               switch (op[2] & 0x00)
2312               {
2313                 case 0x00:
2314                   goto op_semantics_6;
2315                   break;
2316               }
2317             break;
2318           case 0x95:
2319               GETBYTE ();
2320               switch (op[2] & 0x00)
2321               {
2322                 case 0x00:
2323                   goto op_semantics_6;
2324                   break;
2325               }
2326             break;
2327           case 0x96:
2328               GETBYTE ();
2329               switch (op[2] & 0x00)
2330               {
2331                 case 0x00:
2332                   goto op_semantics_6;
2333                   break;
2334               }
2335             break;
2336           case 0x97:
2337               GETBYTE ();
2338               switch (op[2] & 0x00)
2339               {
2340                 case 0x00:
2341                   goto op_semantics_6;
2342                   break;
2343               }
2344             break;
2345           case 0xa0:
2346               GETBYTE ();
2347               switch (op[2] & 0xff)
2348               {
2349                 case 0x00:
2350                     GETBYTE ();
2351                     switch (op[3] & 0x00)
2352                     {
2353                       case 0x00:
2354                         goto op_semantics_7;
2355                         break;
2356                     }
2357                   break;
2358                 case 0x02:
2359                     GETBYTE ();
2360                     switch (op[3] & 0x00)
2361                     {
2362                       case 0x00:
2363                         op_semantics_18:
2364                           {
2365                             /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc     %1%S1, %0 */
2366 #line 474 "rx-decode.opc"
2367                             int ss AU = op[1] & 0x03;
2368 #line 474 "rx-decode.opc"
2369                             int rsrc AU = (op[3] >> 4) & 0x0f;
2370 #line 474 "rx-decode.opc"
2371                             int rdst AU = op[3] & 0x0f;
2372                             if (trace)
2373                               {
2374                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
2375                                        "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst     adc     %1%S1, %0 */",
2376                                        op[0], op[1], op[2], op[3]);
2377                                 printf ("  ss = 0x%x,", ss);
2378                                 printf ("  rsrc = 0x%x,", rsrc);
2379                                 printf ("  rdst = 0x%x\n", rdst);
2380                               }
2381                             SYNTAX("adc %1%S1, %0");
2382 #line 474 "rx-decode.opc"
2383                             ID(adc); SPm(ss, rsrc, 2); DR(rdst); F("OSZC");
2384
2385                           /*----------------------------------------------------------------------*/
2386                           /* ADD                                                                        */
2387
2388                           }
2389                         break;
2390                     }
2391                   break;
2392                 case 0x04:
2393                     GETBYTE ();
2394                     switch (op[3] & 0x00)
2395                     {
2396                       case 0x00:
2397                         goto op_semantics_8;
2398                         break;
2399                     }
2400                   break;
2401                 case 0x05:
2402                     GETBYTE ();
2403                     switch (op[3] & 0x00)
2404                     {
2405                       case 0x00:
2406                         goto op_semantics_9;
2407                         break;
2408                     }
2409                   break;
2410                 case 0x06:
2411                     GETBYTE ();
2412                     switch (op[3] & 0x00)
2413                     {
2414                       case 0x00:
2415                         goto op_semantics_10;
2416                         break;
2417                     }
2418                   break;
2419                 case 0x07:
2420                     GETBYTE ();
2421                     switch (op[3] & 0x00)
2422                     {
2423                       case 0x00:
2424                         goto op_semantics_11;
2425                         break;
2426                     }
2427                   break;
2428                 case 0x08:
2429                     GETBYTE ();
2430                     switch (op[3] & 0x00)
2431                     {
2432                       case 0x00:
2433                         goto op_semantics_12;
2434                         break;
2435                     }
2436                   break;
2437                 case 0x09:
2438                     GETBYTE ();
2439                     switch (op[3] & 0x00)
2440                     {
2441                       case 0x00:
2442                         goto op_semantics_13;
2443                         break;
2444                     }
2445                   break;
2446                 case 0x0c:
2447                     GETBYTE ();
2448                     switch (op[3] & 0x00)
2449                     {
2450                       case 0x00:
2451                         goto op_semantics_14;
2452                         break;
2453                     }
2454                   break;
2455                 case 0x0d:
2456                     GETBYTE ();
2457                     switch (op[3] & 0x00)
2458                     {
2459                       case 0x00:
2460                         goto op_semantics_15;
2461                         break;
2462                     }
2463                   break;
2464                 case 0x10:
2465                     GETBYTE ();
2466                     switch (op[3] & 0x00)
2467                     {
2468                       case 0x00:
2469                         goto op_semantics_16;
2470                         break;
2471                     }
2472                   break;
2473                 case 0x11:
2474                     GETBYTE ();
2475                     switch (op[3] & 0x00)
2476                     {
2477                       case 0x00:
2478                         goto op_semantics_17;
2479                         break;
2480                     }
2481                   break;
2482                 default: UNSUPPORTED(); break;
2483               }
2484             break;
2485           case 0xa1:
2486               GETBYTE ();
2487               switch (op[2] & 0xff)
2488               {
2489                 case 0x00:
2490                     GETBYTE ();
2491                     switch (op[3] & 0x00)
2492                     {
2493                       case 0x00:
2494                         goto op_semantics_7;
2495                         break;
2496                     }
2497                   break;
2498                 case 0x02:
2499                     GETBYTE ();
2500                     switch (op[3] & 0x00)
2501                     {
2502                       case 0x00:
2503                         goto op_semantics_18;
2504                         break;
2505                     }
2506                   break;
2507                 case 0x04:
2508                     GETBYTE ();
2509                     switch (op[3] & 0x00)
2510                     {
2511                       case 0x00:
2512                         goto op_semantics_8;
2513                         break;
2514                     }
2515                   break;
2516                 case 0x05:
2517                     GETBYTE ();
2518                     switch (op[3] & 0x00)
2519                     {
2520                       case 0x00:
2521                         goto op_semantics_9;
2522                         break;
2523                     }
2524                   break;
2525                 case 0x06:
2526                     GETBYTE ();
2527                     switch (op[3] & 0x00)
2528                     {
2529                       case 0x00:
2530                         goto op_semantics_10;
2531                         break;
2532                     }
2533                   break;
2534                 case 0x07:
2535                     GETBYTE ();
2536                     switch (op[3] & 0x00)
2537                     {
2538                       case 0x00:
2539                         goto op_semantics_11;
2540                         break;
2541                     }
2542                   break;
2543                 case 0x08:
2544                     GETBYTE ();
2545                     switch (op[3] & 0x00)
2546                     {
2547                       case 0x00:
2548                         goto op_semantics_12;
2549                         break;
2550                     }
2551                   break;
2552                 case 0x09:
2553                     GETBYTE ();
2554                     switch (op[3] & 0x00)
2555                     {
2556                       case 0x00:
2557                         goto op_semantics_13;
2558                         break;
2559                     }
2560                   break;
2561                 case 0x0c:
2562                     GETBYTE ();
2563                     switch (op[3] & 0x00)
2564                     {
2565                       case 0x00:
2566                         goto op_semantics_14;
2567                         break;
2568                     }
2569                   break;
2570                 case 0x0d:
2571                     GETBYTE ();
2572                     switch (op[3] & 0x00)
2573                     {
2574                       case 0x00:
2575                         goto op_semantics_15;
2576                         break;
2577                     }
2578                   break;
2579                 case 0x10:
2580                     GETBYTE ();
2581                     switch (op[3] & 0x00)
2582                     {
2583                       case 0x00:
2584                         goto op_semantics_16;
2585                         break;
2586                     }
2587                   break;
2588                 case 0x11:
2589                     GETBYTE ();
2590                     switch (op[3] & 0x00)
2591                     {
2592                       case 0x00:
2593                         goto op_semantics_17;
2594                         break;
2595                     }
2596                   break;
2597                 default: UNSUPPORTED(); break;
2598               }
2599             break;
2600           case 0xa2:
2601               GETBYTE ();
2602               switch (op[2] & 0xff)
2603               {
2604                 case 0x00:
2605                     GETBYTE ();
2606                     switch (op[3] & 0x00)
2607                     {
2608                       case 0x00:
2609                         goto op_semantics_7;
2610                         break;
2611                     }
2612                   break;
2613                 case 0x02:
2614                     GETBYTE ();
2615                     switch (op[3] & 0x00)
2616                     {
2617                       case 0x00:
2618                         goto op_semantics_18;
2619                         break;
2620                     }
2621                   break;
2622                 case 0x04:
2623                     GETBYTE ();
2624                     switch (op[3] & 0x00)
2625                     {
2626                       case 0x00:
2627                         goto op_semantics_8;
2628                         break;
2629                     }
2630                   break;
2631                 case 0x05:
2632                     GETBYTE ();
2633                     switch (op[3] & 0x00)
2634                     {
2635                       case 0x00:
2636                         goto op_semantics_9;
2637                         break;
2638                     }
2639                   break;
2640                 case 0x06:
2641                     GETBYTE ();
2642                     switch (op[3] & 0x00)
2643                     {
2644                       case 0x00:
2645                         goto op_semantics_10;
2646                         break;
2647                     }
2648                   break;
2649                 case 0x07:
2650                     GETBYTE ();
2651                     switch (op[3] & 0x00)
2652                     {
2653                       case 0x00:
2654                         goto op_semantics_11;
2655                         break;
2656                     }
2657                   break;
2658                 case 0x08:
2659                     GETBYTE ();
2660                     switch (op[3] & 0x00)
2661                     {
2662                       case 0x00:
2663                         goto op_semantics_12;
2664                         break;
2665                     }
2666                   break;
2667                 case 0x09:
2668                     GETBYTE ();
2669                     switch (op[3] & 0x00)
2670                     {
2671                       case 0x00:
2672                         goto op_semantics_13;
2673                         break;
2674                     }
2675                   break;
2676                 case 0x0c:
2677                     GETBYTE ();
2678                     switch (op[3] & 0x00)
2679                     {
2680                       case 0x00:
2681                         goto op_semantics_14;
2682                         break;
2683                     }
2684                   break;
2685                 case 0x0d:
2686                     GETBYTE ();
2687                     switch (op[3] & 0x00)
2688                     {
2689                       case 0x00:
2690                         goto op_semantics_15;
2691                         break;
2692                     }
2693                   break;
2694                 case 0x10:
2695                     GETBYTE ();
2696                     switch (op[3] & 0x00)
2697                     {
2698                       case 0x00:
2699                         goto op_semantics_16;
2700                         break;
2701                     }
2702                   break;
2703                 case 0x11:
2704                     GETBYTE ();
2705                     switch (op[3] & 0x00)
2706                     {
2707                       case 0x00:
2708                         goto op_semantics_17;
2709                         break;
2710                     }
2711                   break;
2712                 default: UNSUPPORTED(); break;
2713               }
2714             break;
2715           case 0xa3:
2716               GETBYTE ();
2717               switch (op[2] & 0xff)
2718               {
2719                 case 0x00:
2720                     GETBYTE ();
2721                     switch (op[3] & 0x00)
2722                     {
2723                       case 0x00:
2724                         goto op_semantics_7;
2725                         break;
2726                     }
2727                   break;
2728                 case 0x02:
2729                     GETBYTE ();
2730                     switch (op[3] & 0x00)
2731                     {
2732                       case 0x00:
2733                         goto op_semantics_18;
2734                         break;
2735                     }
2736                   break;
2737                 case 0x04:
2738                     GETBYTE ();
2739                     switch (op[3] & 0x00)
2740                     {
2741                       case 0x00:
2742                         goto op_semantics_8;
2743                         break;
2744                     }
2745                   break;
2746                 case 0x05:
2747                     GETBYTE ();
2748                     switch (op[3] & 0x00)
2749                     {
2750                       case 0x00:
2751                         goto op_semantics_9;
2752                         break;
2753                     }
2754                   break;
2755                 case 0x06:
2756                     GETBYTE ();
2757                     switch (op[3] & 0x00)
2758                     {
2759                       case 0x00:
2760                         goto op_semantics_10;
2761                         break;
2762                     }
2763                   break;
2764                 case 0x07:
2765                     GETBYTE ();
2766                     switch (op[3] & 0x00)
2767                     {
2768                       case 0x00:
2769                         goto op_semantics_11;
2770                         break;
2771                     }
2772                   break;
2773                 case 0x08:
2774                     GETBYTE ();
2775                     switch (op[3] & 0x00)
2776                     {
2777                       case 0x00:
2778                         goto op_semantics_12;
2779                         break;
2780                     }
2781                   break;
2782                 case 0x09:
2783                     GETBYTE ();
2784                     switch (op[3] & 0x00)
2785                     {
2786                       case 0x00:
2787                         goto op_semantics_13;
2788                         break;
2789                     }
2790                   break;
2791                 case 0x0c:
2792                     GETBYTE ();
2793                     switch (op[3] & 0x00)
2794                     {
2795                       case 0x00:
2796                         goto op_semantics_14;
2797                         break;
2798                     }
2799                   break;
2800                 case 0x0d:
2801                     GETBYTE ();
2802                     switch (op[3] & 0x00)
2803                     {
2804                       case 0x00:
2805                         goto op_semantics_15;
2806                         break;
2807                     }
2808                   break;
2809                 case 0x10:
2810                     GETBYTE ();
2811                     switch (op[3] & 0x00)
2812                     {
2813                       case 0x00:
2814                         goto op_semantics_16;
2815                         break;
2816                     }
2817                   break;
2818                 case 0x11:
2819                     GETBYTE ();
2820                     switch (op[3] & 0x00)
2821                     {
2822                       case 0x00:
2823                         goto op_semantics_17;
2824                         break;
2825                     }
2826                   break;
2827                 default: UNSUPPORTED(); break;
2828               }
2829             break;
2830           case 0xc0:
2831               GETBYTE ();
2832               switch (op[2] & 0x00)
2833               {
2834                 case 0x00:
2835                   goto op_semantics_1;
2836                   break;
2837               }
2838             break;
2839           case 0xc1:
2840               GETBYTE ();
2841               switch (op[2] & 0x00)
2842               {
2843                 case 0x00:
2844                   goto op_semantics_1;
2845                   break;
2846               }
2847             break;
2848           case 0xc2:
2849               GETBYTE ();
2850               switch (op[2] & 0x00)
2851               {
2852                 case 0x00:
2853                   goto op_semantics_1;
2854                   break;
2855               }
2856             break;
2857           case 0xc3:
2858               GETBYTE ();
2859               switch (op[2] & 0x00)
2860               {
2861                 case 0x00:
2862                   goto op_semantics_1;
2863                   break;
2864               }
2865             break;
2866           case 0xc4:
2867               GETBYTE ();
2868               switch (op[2] & 0x00)
2869               {
2870                 case 0x00:
2871                   goto op_semantics_2;
2872                   break;
2873               }
2874             break;
2875           case 0xc5:
2876               GETBYTE ();
2877               switch (op[2] & 0x00)
2878               {
2879                 case 0x00:
2880                   goto op_semantics_2;
2881                   break;
2882               }
2883             break;
2884           case 0xc6:
2885               GETBYTE ();
2886               switch (op[2] & 0x00)
2887               {
2888                 case 0x00:
2889                   goto op_semantics_2;
2890                   break;
2891               }
2892             break;
2893           case 0xc7:
2894               GETBYTE ();
2895               switch (op[2] & 0x00)
2896               {
2897                 case 0x00:
2898                   goto op_semantics_2;
2899                   break;
2900               }
2901             break;
2902           case 0xc8:
2903               GETBYTE ();
2904               switch (op[2] & 0x00)
2905               {
2906                 case 0x00:
2907                   goto op_semantics_3;
2908                   break;
2909               }
2910             break;
2911           case 0xc9:
2912               GETBYTE ();
2913               switch (op[2] & 0x00)
2914               {
2915                 case 0x00:
2916                   goto op_semantics_3;
2917                   break;
2918               }
2919             break;
2920           case 0xca:
2921               GETBYTE ();
2922               switch (op[2] & 0x00)
2923               {
2924                 case 0x00:
2925                   goto op_semantics_3;
2926                   break;
2927               }
2928             break;
2929           case 0xcb:
2930               GETBYTE ();
2931               switch (op[2] & 0x00)
2932               {
2933                 case 0x00:
2934                   goto op_semantics_3;
2935                   break;
2936               }
2937             break;
2938           case 0xcc:
2939               GETBYTE ();
2940               switch (op[2] & 0x00)
2941               {
2942                 case 0x00:
2943                   goto op_semantics_4;
2944                   break;
2945               }
2946             break;
2947           case 0xcd:
2948               GETBYTE ();
2949               switch (op[2] & 0x00)
2950               {
2951                 case 0x00:
2952                   goto op_semantics_4;
2953                   break;
2954               }
2955             break;
2956           case 0xce:
2957               GETBYTE ();
2958               switch (op[2] & 0x00)
2959               {
2960                 case 0x00:
2961                   goto op_semantics_4;
2962                   break;
2963               }
2964             break;
2965           case 0xcf:
2966               GETBYTE ();
2967               switch (op[2] & 0x00)
2968               {
2969                 case 0x00:
2970                   goto op_semantics_4;
2971                   break;
2972               }
2973             break;
2974           case 0xd0:
2975               GETBYTE ();
2976               switch (op[2] & 0x00)
2977               {
2978                 case 0x00:
2979                   goto op_semantics_5;
2980                   break;
2981               }
2982             break;
2983           case 0xd1:
2984               GETBYTE ();
2985               switch (op[2] & 0x00)
2986               {
2987                 case 0x00:
2988                   goto op_semantics_5;
2989                   break;
2990               }
2991             break;
2992           case 0xd2:
2993               GETBYTE ();
2994               switch (op[2] & 0x00)
2995               {
2996                 case 0x00:
2997                   goto op_semantics_5;
2998                   break;
2999               }
3000             break;
3001           case 0xd3:
3002               GETBYTE ();
3003               switch (op[2] & 0x00)
3004               {
3005                 case 0x00:
3006                   goto op_semantics_5;
3007                   break;
3008               }
3009             break;
3010           case 0xd4:
3011               GETBYTE ();
3012               switch (op[2] & 0x00)
3013               {
3014                 case 0x00:
3015                   goto op_semantics_6;
3016                   break;
3017               }
3018             break;
3019           case 0xd5:
3020               GETBYTE ();
3021               switch (op[2] & 0x00)
3022               {
3023                 case 0x00:
3024                   goto op_semantics_6;
3025                   break;
3026               }
3027             break;
3028           case 0xd6:
3029               GETBYTE ();
3030               switch (op[2] & 0x00)
3031               {
3032                 case 0x00:
3033                   goto op_semantics_6;
3034                   break;
3035               }
3036             break;
3037           case 0xd7:
3038               GETBYTE ();
3039               switch (op[2] & 0x00)
3040               {
3041                 case 0x00:
3042                   goto op_semantics_6;
3043                   break;
3044               }
3045             break;
3046           case 0xe0:
3047               GETBYTE ();
3048               switch (op[2] & 0xff)
3049               {
3050                 case 0x00:
3051                     GETBYTE ();
3052                     switch (op[3] & 0x00)
3053                     {
3054                       case 0x00:
3055                         goto op_semantics_7;
3056                         break;
3057                     }
3058                   break;
3059                 case 0x04:
3060                     GETBYTE ();
3061                     switch (op[3] & 0x00)
3062                     {
3063                       case 0x00:
3064                         goto op_semantics_8;
3065                         break;
3066                     }
3067                   break;
3068                 case 0x05:
3069                     GETBYTE ();
3070                     switch (op[3] & 0x00)
3071                     {
3072                       case 0x00:
3073                         goto op_semantics_9;
3074                         break;
3075                     }
3076                   break;
3077                 case 0x06:
3078                     GETBYTE ();
3079                     switch (op[3] & 0x00)
3080                     {
3081                       case 0x00:
3082                         goto op_semantics_10;
3083                         break;
3084                     }
3085                   break;
3086                 case 0x07:
3087                     GETBYTE ();
3088                     switch (op[3] & 0x00)
3089                     {
3090                       case 0x00:
3091                         goto op_semantics_11;
3092                         break;
3093                     }
3094                   break;
3095                 case 0x08:
3096                     GETBYTE ();
3097                     switch (op[3] & 0x00)
3098                     {
3099                       case 0x00:
3100                         goto op_semantics_12;
3101                         break;
3102                     }
3103                   break;
3104                 case 0x09:
3105                     GETBYTE ();
3106                     switch (op[3] & 0x00)
3107                     {
3108                       case 0x00:
3109                         goto op_semantics_13;
3110                         break;
3111                     }
3112                   break;
3113                 case 0x0c:
3114                     GETBYTE ();
3115                     switch (op[3] & 0x00)
3116                     {
3117                       case 0x00:
3118                         goto op_semantics_14;
3119                         break;
3120                     }
3121                   break;
3122                 case 0x0d:
3123                     GETBYTE ();
3124                     switch (op[3] & 0x00)
3125                     {
3126                       case 0x00:
3127                         goto op_semantics_15;
3128                         break;
3129                     }
3130                   break;
3131                 case 0x10:
3132                     GETBYTE ();
3133                     switch (op[3] & 0x00)
3134                     {
3135                       case 0x00:
3136                         goto op_semantics_16;
3137                         break;
3138                     }
3139                   break;
3140                 case 0x11:
3141                     GETBYTE ();
3142                     switch (op[3] & 0x00)
3143                     {
3144                       case 0x00:
3145                         goto op_semantics_17;
3146                         break;
3147                     }
3148                   break;
3149                 default: UNSUPPORTED(); break;
3150               }
3151             break;
3152           case 0xe1:
3153               GETBYTE ();
3154               switch (op[2] & 0xff)
3155               {
3156                 case 0x00:
3157                     GETBYTE ();
3158                     switch (op[3] & 0x00)
3159                     {
3160                       case 0x00:
3161                         goto op_semantics_7;
3162                         break;
3163                     }
3164                   break;
3165                 case 0x04:
3166                     GETBYTE ();
3167                     switch (op[3] & 0x00)
3168                     {
3169                       case 0x00:
3170                         goto op_semantics_8;
3171                         break;
3172                     }
3173                   break;
3174                 case 0x05:
3175                     GETBYTE ();
3176                     switch (op[3] & 0x00)
3177                     {
3178                       case 0x00:
3179                         goto op_semantics_9;
3180                         break;
3181                     }
3182                   break;
3183                 case 0x06:
3184                     GETBYTE ();
3185                     switch (op[3] & 0x00)
3186                     {
3187                       case 0x00:
3188                         goto op_semantics_10;
3189                         break;
3190                     }
3191                   break;
3192                 case 0x07:
3193                     GETBYTE ();
3194                     switch (op[3] & 0x00)
3195                     {
3196                       case 0x00:
3197                         goto op_semantics_11;
3198                         break;
3199                     }
3200                   break;
3201                 case 0x08:
3202                     GETBYTE ();
3203                     switch (op[3] & 0x00)
3204                     {
3205                       case 0x00:
3206                         goto op_semantics_12;
3207                         break;
3208                     }
3209                   break;
3210                 case 0x09:
3211                     GETBYTE ();
3212                     switch (op[3] & 0x00)
3213                     {
3214                       case 0x00:
3215                         goto op_semantics_13;
3216                         break;
3217                     }
3218                   break;
3219                 case 0x0c:
3220                     GETBYTE ();
3221                     switch (op[3] & 0x00)
3222                     {
3223                       case 0x00:
3224                         goto op_semantics_14;
3225                         break;
3226                     }
3227                   break;
3228                 case 0x0d:
3229                     GETBYTE ();
3230                     switch (op[3] & 0x00)
3231                     {
3232                       case 0x00:
3233                         goto op_semantics_15;
3234                         break;
3235                     }
3236                   break;
3237                 case 0x10:
3238                     GETBYTE ();
3239                     switch (op[3] & 0x00)
3240                     {
3241                       case 0x00:
3242                         goto op_semantics_16;
3243                         break;
3244                     }
3245                   break;
3246                 case 0x11:
3247                     GETBYTE ();
3248                     switch (op[3] & 0x00)
3249                     {
3250                       case 0x00:
3251                         goto op_semantics_17;
3252                         break;
3253                     }
3254                   break;
3255                 default: UNSUPPORTED(); break;
3256               }
3257             break;
3258           case 0xe2:
3259               GETBYTE ();
3260               switch (op[2] & 0xff)
3261               {
3262                 case 0x00:
3263                     GETBYTE ();
3264                     switch (op[3] & 0x00)
3265                     {
3266                       case 0x00:
3267                         goto op_semantics_7;
3268                         break;
3269                     }
3270                   break;
3271                 case 0x04:
3272                     GETBYTE ();
3273                     switch (op[3] & 0x00)
3274                     {
3275                       case 0x00:
3276                         goto op_semantics_8;
3277                         break;
3278                     }
3279                   break;
3280                 case 0x05:
3281                     GETBYTE ();
3282                     switch (op[3] & 0x00)
3283                     {
3284                       case 0x00:
3285                         goto op_semantics_9;
3286                         break;
3287                     }
3288                   break;
3289                 case 0x06:
3290                     GETBYTE ();
3291                     switch (op[3] & 0x00)
3292                     {
3293                       case 0x00:
3294                         goto op_semantics_10;
3295                         break;
3296                     }
3297                   break;
3298                 case 0x07:
3299                     GETBYTE ();
3300                     switch (op[3] & 0x00)
3301                     {
3302                       case 0x00:
3303                         goto op_semantics_11;
3304                         break;
3305                     }
3306                   break;
3307                 case 0x08:
3308                     GETBYTE ();
3309                     switch (op[3] & 0x00)
3310                     {
3311                       case 0x00:
3312                         goto op_semantics_12;
3313                         break;
3314                     }
3315                   break;
3316                 case 0x09:
3317                     GETBYTE ();
3318                     switch (op[3] & 0x00)
3319                     {
3320                       case 0x00:
3321                         goto op_semantics_13;
3322                         break;
3323                     }
3324                   break;
3325                 case 0x0c:
3326                     GETBYTE ();
3327                     switch (op[3] & 0x00)
3328                     {
3329                       case 0x00:
3330                         goto op_semantics_14;
3331                         break;
3332                     }
3333                   break;
3334                 case 0x0d:
3335                     GETBYTE ();
3336                     switch (op[3] & 0x00)
3337                     {
3338                       case 0x00:
3339                         goto op_semantics_15;
3340                         break;
3341                     }
3342                   break;
3343                 case 0x10:
3344                     GETBYTE ();
3345                     switch (op[3] & 0x00)
3346                     {
3347                       case 0x00:
3348                         goto op_semantics_16;
3349                         break;
3350                     }
3351                   break;
3352                 case 0x11:
3353                     GETBYTE ();
3354                     switch (op[3] & 0x00)
3355                     {
3356                       case 0x00:
3357                         goto op_semantics_17;
3358                         break;
3359                     }
3360                   break;
3361                 default: UNSUPPORTED(); break;
3362               }
3363             break;
3364           case 0xe3:
3365               GETBYTE ();
3366               switch (op[2] & 0xff)
3367               {
3368                 case 0x00:
3369                     GETBYTE ();
3370                     switch (op[3] & 0x00)
3371                     {
3372                       case 0x00:
3373                         goto op_semantics_7;
3374                         break;
3375                     }
3376                   break;
3377                 case 0x04:
3378                     GETBYTE ();
3379                     switch (op[3] & 0x00)
3380                     {
3381                       case 0x00:
3382                         goto op_semantics_8;
3383                         break;
3384                     }
3385                   break;
3386                 case 0x05:
3387                     GETBYTE ();
3388                     switch (op[3] & 0x00)
3389                     {
3390                       case 0x00:
3391                         goto op_semantics_9;
3392                         break;
3393                     }
3394                   break;
3395                 case 0x06:
3396                     GETBYTE ();
3397                     switch (op[3] & 0x00)
3398                     {
3399                       case 0x00:
3400                         goto op_semantics_10;
3401                         break;
3402                     }
3403                   break;
3404                 case 0x07:
3405                     GETBYTE ();
3406                     switch (op[3] & 0x00)
3407                     {
3408                       case 0x00:
3409                         goto op_semantics_11;
3410                         break;
3411                     }
3412                   break;
3413                 case 0x08:
3414                     GETBYTE ();
3415                     switch (op[3] & 0x00)
3416                     {
3417                       case 0x00:
3418                         goto op_semantics_12;
3419                         break;
3420                     }
3421                   break;
3422                 case 0x09:
3423                     GETBYTE ();
3424                     switch (op[3] & 0x00)
3425                     {
3426                       case 0x00:
3427                         goto op_semantics_13;
3428                         break;
3429                     }
3430                   break;
3431                 case 0x0c:
3432                     GETBYTE ();
3433                     switch (op[3] & 0x00)
3434                     {
3435                       case 0x00:
3436                         goto op_semantics_14;
3437                         break;
3438                     }
3439                   break;
3440                 case 0x0d:
3441                     GETBYTE ();
3442                     switch (op[3] & 0x00)
3443                     {
3444                       case 0x00:
3445                         goto op_semantics_15;
3446                         break;
3447                     }
3448                   break;
3449                 case 0x10:
3450                     GETBYTE ();
3451                     switch (op[3] & 0x00)
3452                     {
3453                       case 0x00:
3454                         goto op_semantics_16;
3455                         break;
3456                     }
3457                   break;
3458                 case 0x11:
3459                     GETBYTE ();
3460                     switch (op[3] & 0x00)
3461                     {
3462                       case 0x00:
3463                         goto op_semantics_17;
3464                         break;
3465                     }
3466                   break;
3467                 default: UNSUPPORTED(); break;
3468               }
3469             break;
3470           default: UNSUPPORTED(); break;
3471         }
3472       break;
3473     case 0x08:
3474     case 0x09:
3475     case 0x0a:
3476     case 0x0b:
3477     case 0x0c:
3478     case 0x0d:
3479     case 0x0e:
3480     case 0x0f:
3481         {
3482           /** 0000 1dsp                 bra.s   %a0 */
3483 #line 709 "rx-decode.opc"
3484           int dsp AU = op[0] & 0x07;
3485           if (trace)
3486             {
3487               printf ("\033[33m%s\033[0m  %02x\n",
3488                      "/** 0000 1dsp                     bra.s   %a0 */",
3489                      op[0]);
3490               printf ("  dsp = 0x%x\n", dsp);
3491             }
3492           SYNTAX("bra.s %a0");
3493 #line 709 "rx-decode.opc"
3494           ID(branch); Scc(RXC_always); DC(pc + dsp3map[dsp]);
3495
3496         }
3497       break;
3498     case 0x10:
3499     case 0x11:
3500     case 0x12:
3501     case 0x13:
3502     case 0x14:
3503     case 0x15:
3504     case 0x16:
3505     case 0x17:
3506     case 0x18:
3507     case 0x19:
3508     case 0x1a:
3509     case 0x1b:
3510     case 0x1c:
3511     case 0x1d:
3512     case 0x1e:
3513     case 0x1f:
3514         {
3515           /** 0001 n dsp                        b%1.s   %a0 */
3516 #line 699 "rx-decode.opc"
3517           int n AU = (op[0] >> 3) & 0x01;
3518 #line 699 "rx-decode.opc"
3519           int dsp AU = op[0] & 0x07;
3520           if (trace)
3521             {
3522               printf ("\033[33m%s\033[0m  %02x\n",
3523                      "/** 0001 n dsp                    b%1.s   %a0 */",
3524                      op[0]);
3525               printf ("  n = 0x%x,", n);
3526               printf ("  dsp = 0x%x\n", dsp);
3527             }
3528           SYNTAX("b%1.s %a0");
3529 #line 699 "rx-decode.opc"
3530           ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3531
3532         }
3533       break;
3534     case 0x20:
3535     case 0x21:
3536     case 0x22:
3537     case 0x23:
3538     case 0x24:
3539     case 0x25:
3540     case 0x26:
3541     case 0x27:
3542     case 0x28:
3543     case 0x29:
3544     case 0x2a:
3545     case 0x2b:
3546     case 0x2c:
3547     case 0x2d:
3548     case 0x2f:
3549         {
3550           /** 0010 cond                 b%1.b   %a0 */
3551 #line 702 "rx-decode.opc"
3552           int cond AU = op[0] & 0x0f;
3553           if (trace)
3554             {
3555               printf ("\033[33m%s\033[0m  %02x\n",
3556                      "/** 0010 cond                     b%1.b   %a0 */",
3557                      op[0]);
3558               printf ("  cond = 0x%x\n", cond);
3559             }
3560           SYNTAX("b%1.b %a0");
3561 #line 702 "rx-decode.opc"
3562           ID(branch); Scc(cond); DC(pc + IMMex (1));
3563
3564         }
3565       break;
3566     case 0x2e:
3567         {
3568           /** 0010 1110                 bra.b   %a0 */
3569           if (trace)
3570             {
3571               printf ("\033[33m%s\033[0m  %02x\n",
3572                      "/** 0010 1110                     bra.b   %a0 */",
3573                      op[0]);
3574             }
3575           SYNTAX("bra.b %a0");
3576 #line 712 "rx-decode.opc"
3577           ID(branch); Scc(RXC_always); DC(pc + IMMex(1));
3578
3579         }
3580       break;
3581     case 0x38:
3582         {
3583           /** 0011 1000                 bra.w   %a0 */
3584           if (trace)
3585             {
3586               printf ("\033[33m%s\033[0m  %02x\n",
3587                      "/** 0011 1000                     bra.w   %a0 */",
3588                      op[0]);
3589             }
3590           SYNTAX("bra.w %a0");
3591 #line 715 "rx-decode.opc"
3592           ID(branch); Scc(RXC_always); DC(pc + IMMex(2));
3593
3594         }
3595       break;
3596     case 0x39:
3597         {
3598           /** 0011 1001                 bsr.w   %a0 */
3599           if (trace)
3600             {
3601               printf ("\033[33m%s\033[0m  %02x\n",
3602                      "/** 0011 1001                     bsr.w   %a0 */",
3603                      op[0]);
3604             }
3605           SYNTAX("bsr.w %a0");
3606 #line 731 "rx-decode.opc"
3607           ID(jsr); DC(pc + IMMex(2));
3608
3609         }
3610       break;
3611     case 0x3a:
3612     case 0x3b:
3613         {
3614           /** 0011 101c                 b%1.w   %a0 */
3615 #line 705 "rx-decode.opc"
3616           int c AU = op[0] & 0x01;
3617           if (trace)
3618             {
3619               printf ("\033[33m%s\033[0m  %02x\n",
3620                      "/** 0011 101c                     b%1.w   %a0 */",
3621                      op[0]);
3622               printf ("  c = 0x%x\n", c);
3623             }
3624           SYNTAX("b%1.w %a0");
3625 #line 705 "rx-decode.opc"
3626           ID(branch); Scc(c); DC(pc + IMMex (2));
3627
3628
3629         }
3630       break;
3631     case 0x3c:
3632         GETBYTE ();
3633         switch (op[1] & 0x00)
3634         {
3635           case 0x00:
3636             op_semantics_19:
3637               {
3638                 /** 0011 11sz d dst sppp                mov%s   #%1, %0 */
3639 #line 295 "rx-decode.opc"
3640                 int sz AU = op[0] & 0x03;
3641 #line 295 "rx-decode.opc"
3642                 int d AU = (op[1] >> 7) & 0x01;
3643 #line 295 "rx-decode.opc"
3644                 int dst AU = (op[1] >> 4) & 0x07;
3645 #line 295 "rx-decode.opc"
3646                 int sppp AU = op[1] & 0x0f;
3647                 if (trace)
3648                   {
3649                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3650                            "/** 0011 11sz d dst sppp            mov%s   #%1, %0 */",
3651                            op[0], op[1]);
3652                     printf ("  sz = 0x%x,", sz);
3653                     printf ("  d = 0x%x,", d);
3654                     printf ("  dst = 0x%x,", dst);
3655                     printf ("  sppp = 0x%x\n", sppp);
3656                   }
3657                 SYNTAX("mov%s   #%1, %0");
3658 #line 295 "rx-decode.opc"
3659                 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F("----");
3660
3661               }
3662             break;
3663         }
3664       break;
3665     case 0x3d:
3666         GETBYTE ();
3667         switch (op[1] & 0x00)
3668         {
3669           case 0x00:
3670             goto op_semantics_19;
3671             break;
3672         }
3673       break;
3674     case 0x3e:
3675         GETBYTE ();
3676         switch (op[1] & 0x00)
3677         {
3678           case 0x00:
3679             goto op_semantics_19;
3680             break;
3681         }
3682       break;
3683     case 0x3f:
3684         GETBYTE ();
3685         switch (op[1] & 0x00)
3686         {
3687           case 0x00:
3688               {
3689                 /** 0011 1111 rega regb         rtsd    #%1, %2-%0 */
3690 #line 384 "rx-decode.opc"
3691                 int rega AU = (op[1] >> 4) & 0x0f;
3692 #line 384 "rx-decode.opc"
3693                 int regb AU = op[1] & 0x0f;
3694                 if (trace)
3695                   {
3696                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3697                            "/** 0011 1111 rega regb             rtsd    #%1, %2-%0 */",
3698                            op[0], op[1]);
3699                     printf ("  rega = 0x%x,", rega);
3700                     printf ("  regb = 0x%x\n", regb);
3701                   }
3702                 SYNTAX("rtsd    #%1, %2-%0");
3703 #line 384 "rx-decode.opc"
3704                 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3705
3706               /*----------------------------------------------------------------------*/
3707               /* AND                                                                    */
3708
3709               }
3710             break;
3711         }
3712       break;
3713     case 0x40:
3714         GETBYTE ();
3715         switch (op[1] & 0x00)
3716         {
3717           case 0x00:
3718             op_semantics_20:
3719               {
3720                 /** 0100 00ss rsrc rdst                 sub     %2%S2, %1 */
3721 #line 519 "rx-decode.opc"
3722                 int ss AU = op[0] & 0x03;
3723 #line 519 "rx-decode.opc"
3724                 int rsrc AU = (op[1] >> 4) & 0x0f;
3725 #line 519 "rx-decode.opc"
3726                 int rdst AU = op[1] & 0x0f;
3727                 if (trace)
3728                   {
3729                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3730                            "/** 0100 00ss rsrc rdst                     sub     %2%S2, %1 */",
3731                            op[0], op[1]);
3732                     printf ("  ss = 0x%x,", ss);
3733                     printf ("  rsrc = 0x%x,", rsrc);
3734                     printf ("  rdst = 0x%x\n", rdst);
3735                   }
3736                 SYNTAX("sub     %2%S2, %1");
3737 #line 519 "rx-decode.opc"
3738                 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F("OSZC");
3739
3740               }
3741             break;
3742         }
3743       break;
3744     case 0x41:
3745         GETBYTE ();
3746         switch (op[1] & 0x00)
3747         {
3748           case 0x00:
3749             goto op_semantics_20;
3750             break;
3751         }
3752       break;
3753     case 0x42:
3754         GETBYTE ();
3755         switch (op[1] & 0x00)
3756         {
3757           case 0x00:
3758             goto op_semantics_20;
3759             break;
3760         }
3761       break;
3762     case 0x43:
3763         GETBYTE ();
3764         switch (op[1] & 0x00)
3765         {
3766           case 0x00:
3767             goto op_semantics_20;
3768             break;
3769         }
3770       break;
3771     case 0x44:
3772         GETBYTE ();
3773         switch (op[1] & 0x00)
3774         {
3775           case 0x00:
3776             op_semantics_21:
3777               {
3778                 /** 0100 01ss rsrc rdst         cmp     %2%S2, %1 */
3779 #line 507 "rx-decode.opc"
3780                 int ss AU = op[0] & 0x03;
3781 #line 507 "rx-decode.opc"
3782                 int rsrc AU = (op[1] >> 4) & 0x0f;
3783 #line 507 "rx-decode.opc"
3784                 int rdst AU = op[1] & 0x0f;
3785                 if (trace)
3786                   {
3787                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3788                            "/** 0100 01ss rsrc rdst             cmp     %2%S2, %1 */",
3789                            op[0], op[1]);
3790                     printf ("  ss = 0x%x,", ss);
3791                     printf ("  rsrc = 0x%x,", rsrc);
3792                     printf ("  rdst = 0x%x\n", rdst);
3793                   }
3794                 SYNTAX("cmp     %2%S2, %1");
3795 #line 507 "rx-decode.opc"
3796                 ID(sub); S2P(ss, rsrc); SR(rdst); F("OSZC");
3797
3798               }
3799             break;
3800         }
3801       break;
3802     case 0x45:
3803         GETBYTE ();
3804         switch (op[1] & 0x00)
3805         {
3806           case 0x00:
3807             goto op_semantics_21;
3808             break;
3809         }
3810       break;
3811     case 0x46:
3812         GETBYTE ();
3813         switch (op[1] & 0x00)
3814         {
3815           case 0x00:
3816             goto op_semantics_21;
3817             break;
3818         }
3819       break;
3820     case 0x47:
3821         GETBYTE ();
3822         switch (op[1] & 0x00)
3823         {
3824           case 0x00:
3825             goto op_semantics_21;
3826             break;
3827         }
3828       break;
3829     case 0x48:
3830         GETBYTE ();
3831         switch (op[1] & 0x00)
3832         {
3833           case 0x00:
3834             op_semantics_22:
3835               {
3836                 /** 0100 10ss rsrc rdst                 add     %1%S1, %0 */
3837 #line 483 "rx-decode.opc"
3838                 int ss AU = op[0] & 0x03;
3839 #line 483 "rx-decode.opc"
3840                 int rsrc AU = (op[1] >> 4) & 0x0f;
3841 #line 483 "rx-decode.opc"
3842                 int rdst AU = op[1] & 0x0f;
3843                 if (trace)
3844                   {
3845                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3846                            "/** 0100 10ss rsrc rdst                     add     %1%S1, %0 */",
3847                            op[0], op[1]);
3848                     printf ("  ss = 0x%x,", ss);
3849                     printf ("  rsrc = 0x%x,", rsrc);
3850                     printf ("  rdst = 0x%x\n", rdst);
3851                   }
3852                 SYNTAX("add     %1%S1, %0");
3853 #line 483 "rx-decode.opc"
3854                 ID(add); SP(ss, rsrc); DR(rdst); F("OSZC");
3855
3856               }
3857             break;
3858         }
3859       break;
3860     case 0x49:
3861         GETBYTE ();
3862         switch (op[1] & 0x00)
3863         {
3864           case 0x00:
3865             goto op_semantics_22;
3866             break;
3867         }
3868       break;
3869     case 0x4a:
3870         GETBYTE ();
3871         switch (op[1] & 0x00)
3872         {
3873           case 0x00:
3874             goto op_semantics_22;
3875             break;
3876         }
3877       break;
3878     case 0x4b:
3879         GETBYTE ();
3880         switch (op[1] & 0x00)
3881         {
3882           case 0x00:
3883             goto op_semantics_22;
3884             break;
3885         }
3886       break;
3887     case 0x4c:
3888         GETBYTE ();
3889         switch (op[1] & 0x00)
3890         {
3891           case 0x00:
3892             op_semantics_23:
3893               {
3894                 /** 0100 11ss rsrc rdst                 mul     %1%S1, %0 */
3895 #line 580 "rx-decode.opc"
3896                 int ss AU = op[0] & 0x03;
3897 #line 580 "rx-decode.opc"
3898                 int rsrc AU = (op[1] >> 4) & 0x0f;
3899 #line 580 "rx-decode.opc"
3900                 int rdst AU = op[1] & 0x0f;
3901                 if (trace)
3902                   {
3903                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3904                            "/** 0100 11ss rsrc rdst                     mul     %1%S1, %0 */",
3905                            op[0], op[1]);
3906                     printf ("  ss = 0x%x,", ss);
3907                     printf ("  rsrc = 0x%x,", rsrc);
3908                     printf ("  rdst = 0x%x\n", rdst);
3909                   }
3910                 SYNTAX("mul     %1%S1, %0");
3911 #line 580 "rx-decode.opc"
3912                 ID(mul); SP(ss, rsrc); DR(rdst); F("----");
3913
3914               }
3915             break;
3916         }
3917       break;
3918     case 0x4d:
3919         GETBYTE ();
3920         switch (op[1] & 0x00)
3921         {
3922           case 0x00:
3923             goto op_semantics_23;
3924             break;
3925         }
3926       break;
3927     case 0x4e:
3928         GETBYTE ();
3929         switch (op[1] & 0x00)
3930         {
3931           case 0x00:
3932             goto op_semantics_23;
3933             break;
3934         }
3935       break;
3936     case 0x4f:
3937         GETBYTE ();
3938         switch (op[1] & 0x00)
3939         {
3940           case 0x00:
3941             goto op_semantics_23;
3942             break;
3943         }
3944       break;
3945     case 0x50:
3946         GETBYTE ();
3947         switch (op[1] & 0x00)
3948         {
3949           case 0x00:
3950             op_semantics_24:
3951               {
3952                 /** 0101 00ss rsrc rdst                 and     %1%S1, %0 */
3953 #line 396 "rx-decode.opc"
3954                 int ss AU = op[0] & 0x03;
3955 #line 396 "rx-decode.opc"
3956                 int rsrc AU = (op[1] >> 4) & 0x0f;
3957 #line 396 "rx-decode.opc"
3958                 int rdst AU = op[1] & 0x0f;
3959                 if (trace)
3960                   {
3961                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3962                            "/** 0101 00ss rsrc rdst                     and     %1%S1, %0 */",
3963                            op[0], op[1]);
3964                     printf ("  ss = 0x%x,", ss);
3965                     printf ("  rsrc = 0x%x,", rsrc);
3966                     printf ("  rdst = 0x%x\n", rdst);
3967                   }
3968                 SYNTAX("and     %1%S1, %0");
3969 #line 396 "rx-decode.opc"
3970                 ID(and); SP(ss, rsrc); DR(rdst); F("-SZ-");
3971
3972               }
3973             break;
3974         }
3975       break;
3976     case 0x51:
3977         GETBYTE ();
3978         switch (op[1] & 0x00)
3979         {
3980           case 0x00:
3981             goto op_semantics_24;
3982             break;
3983         }
3984       break;
3985     case 0x52:
3986         GETBYTE ();
3987         switch (op[1] & 0x00)
3988         {
3989           case 0x00:
3990             goto op_semantics_24;
3991             break;
3992         }
3993       break;
3994     case 0x53:
3995         GETBYTE ();
3996         switch (op[1] & 0x00)
3997         {
3998           case 0x00:
3999             goto op_semantics_24;
4000             break;
4001         }
4002       break;
4003     case 0x54:
4004         GETBYTE ();
4005         switch (op[1] & 0x00)
4006         {
4007           case 0x00:
4008             op_semantics_25:
4009               {
4010                 /** 0101 01ss rsrc rdst                 or      %1%S1, %0 */
4011 #line 414 "rx-decode.opc"
4012                 int ss AU = op[0] & 0x03;
4013 #line 414 "rx-decode.opc"
4014                 int rsrc AU = (op[1] >> 4) & 0x0f;
4015 #line 414 "rx-decode.opc"
4016                 int rdst AU = op[1] & 0x0f;
4017                 if (trace)
4018                   {
4019                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4020                            "/** 0101 01ss rsrc rdst                     or      %1%S1, %0 */",
4021                            op[0], op[1]);
4022                     printf ("  ss = 0x%x,", ss);
4023                     printf ("  rsrc = 0x%x,", rsrc);
4024                     printf ("  rdst = 0x%x\n", rdst);
4025                   }
4026                 SYNTAX("or      %1%S1, %0");
4027 #line 414 "rx-decode.opc"
4028                 ID(or); SP(ss, rsrc); DR(rdst); F("-SZ-");
4029
4030               }
4031             break;
4032         }
4033       break;
4034     case 0x55:
4035         GETBYTE ();
4036         switch (op[1] & 0x00)
4037         {
4038           case 0x00:
4039             goto op_semantics_25;
4040             break;
4041         }
4042       break;
4043     case 0x56:
4044         GETBYTE ();
4045         switch (op[1] & 0x00)
4046         {
4047           case 0x00:
4048             goto op_semantics_25;
4049             break;
4050         }
4051       break;
4052     case 0x57:
4053         GETBYTE ();
4054         switch (op[1] & 0x00)
4055         {
4056           case 0x00:
4057             goto op_semantics_25;
4058             break;
4059         }
4060       break;
4061     case 0x58:
4062         GETBYTE ();
4063         switch (op[1] & 0x00)
4064         {
4065           case 0x00:
4066             op_semantics_26:
4067               {
4068                 /** 0101 1 s ss rsrc rdst       movu%s  %1, %0 */
4069 #line 335 "rx-decode.opc"
4070                 int s AU = (op[0] >> 2) & 0x01;
4071 #line 335 "rx-decode.opc"
4072                 int ss AU = op[0] & 0x03;
4073 #line 335 "rx-decode.opc"
4074                 int rsrc AU = (op[1] >> 4) & 0x0f;
4075 #line 335 "rx-decode.opc"
4076                 int rdst AU = op[1] & 0x0f;
4077                 if (trace)
4078                   {
4079                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4080                            "/** 0101 1 s ss rsrc rdst   movu%s  %1, %0 */",
4081                            op[0], op[1]);
4082                     printf ("  s = 0x%x,", s);
4083                     printf ("  ss = 0x%x,", ss);
4084                     printf ("  rsrc = 0x%x,", rsrc);
4085                     printf ("  rdst = 0x%x\n", rdst);
4086                   }
4087                 SYNTAX("movu%s  %1, %0");
4088 #line 335 "rx-decode.opc"
4089                 ID(mov); uBWL(s); SD(ss, rsrc, s); DR(rdst); F("----");
4090
4091               }
4092             break;
4093         }
4094       break;
4095     case 0x59:
4096         GETBYTE ();
4097         switch (op[1] & 0x00)
4098         {
4099           case 0x00:
4100             goto op_semantics_26;
4101             break;
4102         }
4103       break;
4104     case 0x5a:
4105         GETBYTE ();
4106         switch (op[1] & 0x00)
4107         {
4108           case 0x00:
4109             goto op_semantics_26;
4110             break;
4111         }
4112       break;
4113     case 0x5b:
4114         GETBYTE ();
4115         switch (op[1] & 0x00)
4116         {
4117           case 0x00:
4118             goto op_semantics_26;
4119             break;
4120         }
4121       break;
4122     case 0x5c:
4123         GETBYTE ();
4124         switch (op[1] & 0x00)
4125         {
4126           case 0x00:
4127             goto op_semantics_26;
4128             break;
4129         }
4130       break;
4131     case 0x5d:
4132         GETBYTE ();
4133         switch (op[1] & 0x00)
4134         {
4135           case 0x00:
4136             goto op_semantics_26;
4137             break;
4138         }
4139       break;
4140     case 0x5e:
4141         GETBYTE ();
4142         switch (op[1] & 0x00)
4143         {
4144           case 0x00:
4145             goto op_semantics_26;
4146             break;
4147         }
4148       break;
4149     case 0x5f:
4150         GETBYTE ();
4151         switch (op[1] & 0x00)
4152         {
4153           case 0x00:
4154             goto op_semantics_26;
4155             break;
4156         }
4157       break;
4158     case 0x60:
4159         GETBYTE ();
4160         switch (op[1] & 0x00)
4161         {
4162           case 0x00:
4163               {
4164                 /** 0110 0000 immm rdst                 sub     #%2, %0 */
4165 #line 516 "rx-decode.opc"
4166                 int immm AU = (op[1] >> 4) & 0x0f;
4167 #line 516 "rx-decode.opc"
4168                 int rdst AU = op[1] & 0x0f;
4169                 if (trace)
4170                   {
4171                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4172                            "/** 0110 0000 immm rdst                     sub     #%2, %0 */",
4173                            op[0], op[1]);
4174                     printf ("  immm = 0x%x,", immm);
4175                     printf ("  rdst = 0x%x\n", rdst);
4176                   }
4177                 SYNTAX("sub     #%2, %0");
4178 #line 516 "rx-decode.opc"
4179                 ID(sub); S2C(immm); SR(rdst); DR(rdst); F("OSZC");
4180
4181               }
4182             break;
4183         }
4184       break;
4185     case 0x61:
4186         GETBYTE ();
4187         switch (op[1] & 0x00)
4188         {
4189           case 0x00:
4190               {
4191                 /** 0110 0001 immm rdst                 cmp     #%2, %1 */
4192 #line 498 "rx-decode.opc"
4193                 int immm AU = (op[1] >> 4) & 0x0f;
4194 #line 498 "rx-decode.opc"
4195                 int rdst AU = op[1] & 0x0f;
4196                 if (trace)
4197                   {
4198                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4199                            "/** 0110 0001 immm rdst                     cmp     #%2, %1 */",
4200                            op[0], op[1]);
4201                     printf ("  immm = 0x%x,", immm);
4202                     printf ("  rdst = 0x%x\n", rdst);
4203                   }
4204                 SYNTAX("cmp     #%2, %1");
4205 #line 498 "rx-decode.opc"
4206                 ID(sub); S2C(immm); SR(rdst); F("OSZC");
4207
4208               }
4209             break;
4210         }
4211       break;
4212     case 0x62:
4213         GETBYTE ();
4214         switch (op[1] & 0x00)
4215         {
4216           case 0x00:
4217               {
4218                 /** 0110 0010 immm rdst                 add     #%1, %0 */
4219 #line 480 "rx-decode.opc"
4220                 int immm AU = (op[1] >> 4) & 0x0f;
4221 #line 480 "rx-decode.opc"
4222                 int rdst AU = op[1] & 0x0f;
4223                 if (trace)
4224                   {
4225                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4226                            "/** 0110 0010 immm rdst                     add     #%1, %0 */",
4227                            op[0], op[1]);
4228                     printf ("  immm = 0x%x,", immm);
4229                     printf ("  rdst = 0x%x\n", rdst);
4230                   }
4231                 SYNTAX("add     #%1, %0");
4232 #line 480 "rx-decode.opc"
4233                 ID(add); SC(immm); DR(rdst); F("OSZC");
4234
4235               }
4236             break;
4237         }
4238       break;
4239     case 0x63:
4240         GETBYTE ();
4241         switch (op[1] & 0x00)
4242         {
4243           case 0x00:
4244               {
4245                 /** 0110 0011 immm rdst                 mul     #%1, %0 */
4246 #line 574 "rx-decode.opc"
4247                 int immm AU = (op[1] >> 4) & 0x0f;
4248 #line 574 "rx-decode.opc"
4249                 int rdst AU = op[1] & 0x0f;
4250                 if (trace)
4251                   {
4252                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4253                            "/** 0110 0011 immm rdst                     mul     #%1, %0 */",
4254                            op[0], op[1]);
4255                     printf ("  immm = 0x%x,", immm);
4256                     printf ("  rdst = 0x%x\n", rdst);
4257                   }
4258                 SYNTAX("mul     #%1, %0");
4259 #line 574 "rx-decode.opc"
4260                 ID(mul); DR(rdst); SC(immm); F("----");
4261
4262               }
4263             break;
4264         }
4265       break;
4266     case 0x64:
4267         GETBYTE ();
4268         switch (op[1] & 0x00)
4269         {
4270           case 0x00:
4271               {
4272                 /** 0110 0100 immm rdst                 and     #%1, %0 */
4273 #line 390 "rx-decode.opc"
4274                 int immm AU = (op[1] >> 4) & 0x0f;
4275 #line 390 "rx-decode.opc"
4276                 int rdst AU = op[1] & 0x0f;
4277                 if (trace)
4278                   {
4279                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4280                            "/** 0110 0100 immm rdst                     and     #%1, %0 */",
4281                            op[0], op[1]);
4282                     printf ("  immm = 0x%x,", immm);
4283                     printf ("  rdst = 0x%x\n", rdst);
4284                   }
4285                 SYNTAX("and     #%1, %0");
4286 #line 390 "rx-decode.opc"
4287                 ID(and); SC(immm); DR(rdst); F("-SZ-");
4288
4289               }
4290             break;
4291         }
4292       break;
4293     case 0x65:
4294         GETBYTE ();
4295         switch (op[1] & 0x00)
4296         {
4297           case 0x00:
4298               {
4299                 /** 0110 0101 immm rdst                 or      #%1, %0 */
4300 #line 408 "rx-decode.opc"
4301                 int immm AU = (op[1] >> 4) & 0x0f;
4302 #line 408 "rx-decode.opc"
4303                 int rdst AU = op[1] & 0x0f;
4304                 if (trace)
4305                   {
4306                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4307                            "/** 0110 0101 immm rdst                     or      #%1, %0 */",
4308                            op[0], op[1]);
4309                     printf ("  immm = 0x%x,", immm);
4310                     printf ("  rdst = 0x%x\n", rdst);
4311                   }
4312                 SYNTAX("or      #%1, %0");
4313 #line 408 "rx-decode.opc"
4314                 ID(or); SC(immm); DR(rdst); F("-SZ-");
4315
4316               }
4317             break;
4318         }
4319       break;
4320     case 0x66:
4321         GETBYTE ();
4322         switch (op[1] & 0x00)
4323         {
4324           case 0x00:
4325               {
4326                 /** 0110 0110 immm rdst         mov%s   #%1, %0 */
4327 #line 292 "rx-decode.opc"
4328                 int immm AU = (op[1] >> 4) & 0x0f;
4329 #line 292 "rx-decode.opc"
4330                 int rdst AU = op[1] & 0x0f;
4331                 if (trace)
4332                   {
4333                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4334                            "/** 0110 0110 immm rdst             mov%s   #%1, %0 */",
4335                            op[0], op[1]);
4336                     printf ("  immm = 0x%x,", immm);
4337                     printf ("  rdst = 0x%x\n", rdst);
4338                   }
4339                 SYNTAX("mov%s   #%1, %0");
4340 #line 292 "rx-decode.opc"
4341                 ID(mov); DR(rdst); SC(immm); F("----");
4342
4343               }
4344             break;
4345         }
4346       break;
4347     case 0x67:
4348         {
4349           /** 0110 0111                 rtsd    #%1 */
4350           if (trace)
4351             {
4352               printf ("\033[33m%s\033[0m  %02x\n",
4353                      "/** 0110 0111                     rtsd    #%1 */",
4354                      op[0]);
4355             }
4356           SYNTAX("rtsd  #%1");
4357 #line 381 "rx-decode.opc"
4358           ID(rtsd); SC(IMM(1) * 4);
4359
4360         }
4361       break;
4362     case 0x68:
4363         GETBYTE ();
4364         switch (op[1] & 0x00)
4365         {
4366           case 0x00:
4367             op_semantics_27:
4368               {
4369                 /** 0110 100i mmmm rdst                 shlr    #%2, %0 */
4370 #line 660 "rx-decode.opc"
4371                 int i AU = op[0] & 0x01;
4372 #line 660 "rx-decode.opc"
4373                 int mmmm AU = (op[1] >> 4) & 0x0f;
4374 #line 660 "rx-decode.opc"
4375                 int rdst AU = op[1] & 0x0f;
4376                 if (trace)
4377                   {
4378                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4379                            "/** 0110 100i mmmm rdst                     shlr    #%2, %0 */",
4380                            op[0], op[1]);
4381                     printf ("  i = 0x%x,", i);
4382                     printf ("  mmmm = 0x%x,", mmmm);
4383                     printf ("  rdst = 0x%x\n", rdst);
4384                   }
4385                 SYNTAX("shlr    #%2, %0");
4386 #line 660 "rx-decode.opc"
4387                 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F("-SZC");
4388
4389               }
4390             break;
4391         }
4392       break;
4393     case 0x69:
4394         GETBYTE ();
4395         switch (op[1] & 0x00)
4396         {
4397           case 0x00:
4398             goto op_semantics_27;
4399             break;
4400         }
4401       break;
4402     case 0x6a:
4403         GETBYTE ();
4404         switch (op[1] & 0x00)
4405         {
4406           case 0x00:
4407             op_semantics_28:
4408               {
4409                 /** 0110 101i mmmm rdst                 shar    #%2, %0 */
4410 #line 650 "rx-decode.opc"
4411                 int i AU = op[0] & 0x01;
4412 #line 650 "rx-decode.opc"
4413                 int mmmm AU = (op[1] >> 4) & 0x0f;
4414 #line 650 "rx-decode.opc"
4415                 int rdst AU = op[1] & 0x0f;
4416                 if (trace)
4417                   {
4418                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4419                            "/** 0110 101i mmmm rdst                     shar    #%2, %0 */",
4420                            op[0], op[1]);
4421                     printf ("  i = 0x%x,", i);
4422                     printf ("  mmmm = 0x%x,", mmmm);
4423                     printf ("  rdst = 0x%x\n", rdst);
4424                   }
4425                 SYNTAX("shar    #%2, %0");
4426 #line 650 "rx-decode.opc"
4427                 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F("0SZC");
4428
4429               }
4430             break;
4431         }
4432       break;
4433     case 0x6b:
4434         GETBYTE ();
4435         switch (op[1] & 0x00)
4436         {
4437           case 0x00:
4438             goto op_semantics_28;
4439             break;
4440         }
4441       break;
4442     case 0x6c:
4443         GETBYTE ();
4444         switch (op[1] & 0x00)
4445         {
4446           case 0x00:
4447             op_semantics_29:
4448               {
4449                 /** 0110 110i mmmm rdst                 shll    #%2, %0 */
4450 #line 640 "rx-decode.opc"
4451                 int i AU = op[0] & 0x01;
4452 #line 640 "rx-decode.opc"
4453                 int mmmm AU = (op[1] >> 4) & 0x0f;
4454 #line 640 "rx-decode.opc"
4455                 int rdst AU = op[1] & 0x0f;
4456                 if (trace)
4457                   {
4458                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4459                            "/** 0110 110i mmmm rdst                     shll    #%2, %0 */",
4460                            op[0], op[1]);
4461                     printf ("  i = 0x%x,", i);
4462                     printf ("  mmmm = 0x%x,", mmmm);
4463                     printf ("  rdst = 0x%x\n", rdst);
4464                   }
4465                 SYNTAX("shll    #%2, %0");
4466 #line 640 "rx-decode.opc"
4467                 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F("OSZC");
4468
4469               }
4470             break;
4471         }
4472       break;
4473     case 0x6d:
4474         GETBYTE ();
4475         switch (op[1] & 0x00)
4476         {
4477           case 0x00:
4478             goto op_semantics_29;
4479             break;
4480         }
4481       break;
4482     case 0x6e:
4483         GETBYTE ();
4484         switch (op[1] & 0x00)
4485         {
4486           case 0x00:
4487               {
4488                 /** 0110 1110 dsta dstb         pushm   %1-%2 */
4489 #line 348 "rx-decode.opc"
4490                 int dsta AU = (op[1] >> 4) & 0x0f;
4491 #line 348 "rx-decode.opc"
4492                 int dstb AU = op[1] & 0x0f;
4493                 if (trace)
4494                   {
4495                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4496                            "/** 0110 1110 dsta dstb             pushm   %1-%2 */",
4497                            op[0], op[1]);
4498                     printf ("  dsta = 0x%x,", dsta);
4499                     printf ("  dstb = 0x%x\n", dstb);
4500                   }
4501                 SYNTAX("pushm   %1-%2");
4502 #line 348 "rx-decode.opc"
4503                 ID(pushm); SR(dsta); S2R(dstb); F("----");
4504
4505               }
4506             break;
4507         }
4508       break;
4509     case 0x6f:
4510         GETBYTE ();
4511         switch (op[1] & 0x00)
4512         {
4513           case 0x00:
4514               {
4515                 /** 0110 1111 dsta dstb         popm    %1-%2 */
4516 #line 345 "rx-decode.opc"
4517                 int dsta AU = (op[1] >> 4) & 0x0f;
4518 #line 345 "rx-decode.opc"
4519                 int dstb AU = op[1] & 0x0f;
4520                 if (trace)
4521                   {
4522                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4523                            "/** 0110 1111 dsta dstb             popm    %1-%2 */",
4524                            op[0], op[1]);
4525                     printf ("  dsta = 0x%x,", dsta);
4526                     printf ("  dstb = 0x%x\n", dstb);
4527                   }
4528                 SYNTAX("popm    %1-%2");
4529 #line 345 "rx-decode.opc"
4530                 ID(popm); SR(dsta); S2R(dstb); F("----");
4531
4532               }
4533             break;
4534         }
4535       break;
4536     case 0x70:
4537         GETBYTE ();
4538         switch (op[1] & 0x00)
4539         {
4540           case 0x00:
4541             op_semantics_30:
4542               {
4543                 /** 0111 00im rsrc rdst                 add     #%1, %2, %0 */
4544 #line 489 "rx-decode.opc"
4545                 int im AU = op[0] & 0x03;
4546 #line 489 "rx-decode.opc"
4547                 int rsrc AU = (op[1] >> 4) & 0x0f;
4548 #line 489 "rx-decode.opc"
4549                 int rdst AU = op[1] & 0x0f;
4550                 if (trace)
4551                   {
4552                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4553                            "/** 0111 00im rsrc rdst                     add     #%1, %2, %0 */",
4554                            op[0], op[1]);
4555                     printf ("  im = 0x%x,", im);
4556                     printf ("  rsrc = 0x%x,", rsrc);
4557                     printf ("  rdst = 0x%x\n", rdst);
4558                   }
4559                 SYNTAX("add     #%1, %2, %0");
4560 #line 489 "rx-decode.opc"
4561                 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F("OSZC");
4562
4563               }
4564             break;
4565         }
4566       break;
4567     case 0x71:
4568         GETBYTE ();
4569         switch (op[1] & 0x00)
4570         {
4571           case 0x00:
4572             goto op_semantics_30;
4573             break;
4574         }
4575       break;
4576     case 0x72:
4577         GETBYTE ();
4578         switch (op[1] & 0x00)
4579         {
4580           case 0x00:
4581             goto op_semantics_30;
4582             break;
4583         }
4584       break;
4585     case 0x73:
4586         GETBYTE ();
4587         switch (op[1] & 0x00)
4588         {
4589           case 0x00:
4590             goto op_semantics_30;
4591             break;
4592         }
4593       break;
4594     case 0x74:
4595         GETBYTE ();
4596         switch (op[1] & 0xf0)
4597         {
4598           case 0x00:
4599             op_semantics_31:
4600               {
4601                 /** 0111 01im 0000 rsrc         cmp     #%2, %1%S1 */
4602 #line 501 "rx-decode.opc"
4603                 int im AU = op[0] & 0x03;
4604 #line 501 "rx-decode.opc"
4605                 int rsrc AU = op[1] & 0x0f;
4606                 if (trace)
4607                   {
4608                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4609                            "/** 0111 01im 0000 rsrc             cmp     #%2, %1%S1 */",
4610                            op[0], op[1]);
4611                     printf ("  im = 0x%x,", im);
4612                     printf ("  rsrc = 0x%x\n", rsrc);
4613                   }
4614                 SYNTAX("cmp     #%2, %1%S1");
4615 #line 501 "rx-decode.opc"
4616                 ID(sub); SR(rsrc); S2C(IMMex(im)); F("OSZC");
4617
4618               }
4619             break;
4620           case 0x10:
4621             op_semantics_32:
4622               {
4623                 /** 0111 01im 0001rdst                  mul     #%1, %0 */
4624 #line 577 "rx-decode.opc"
4625                 int im AU = op[0] & 0x03;
4626 #line 577 "rx-decode.opc"
4627                 int rdst AU = op[1] & 0x0f;
4628                 if (trace)
4629                   {
4630                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4631                            "/** 0111 01im 0001rdst                      mul     #%1, %0 */",
4632                            op[0], op[1]);
4633                     printf ("  im = 0x%x,", im);
4634                     printf ("  rdst = 0x%x\n", rdst);
4635                   }
4636                 SYNTAX("mul     #%1, %0");
4637 #line 577 "rx-decode.opc"
4638                 ID(mul); DR(rdst); SC(IMMex(im)); F("----");
4639
4640               }
4641             break;
4642           case 0x20:
4643             op_semantics_33:
4644               {
4645                 /** 0111 01im 0010 rdst                 and     #%1, %0 */
4646 #line 393 "rx-decode.opc"
4647                 int im AU = op[0] & 0x03;
4648 #line 393 "rx-decode.opc"
4649                 int rdst AU = op[1] & 0x0f;
4650                 if (trace)
4651                   {
4652                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4653                            "/** 0111 01im 0010 rdst                     and     #%1, %0 */",
4654                            op[0], op[1]);
4655                     printf ("  im = 0x%x,", im);
4656                     printf ("  rdst = 0x%x\n", rdst);
4657                   }
4658                 SYNTAX("and     #%1, %0");
4659 #line 393 "rx-decode.opc"
4660                 ID(and); SC(IMMex(im)); DR(rdst); F("-SZ-");
4661
4662               }
4663             break;
4664           case 0x30:
4665             op_semantics_34:
4666               {
4667                 /** 0111 01im 0011 rdst                 or      #%1, %0 */
4668 #line 411 "rx-decode.opc"
4669                 int im AU = op[0] & 0x03;
4670 #line 411 "rx-decode.opc"
4671                 int rdst AU = op[1] & 0x0f;
4672                 if (trace)
4673                   {
4674                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4675                            "/** 0111 01im 0011 rdst                     or      #%1, %0 */",
4676                            op[0], op[1]);
4677                     printf ("  im = 0x%x,", im);
4678                     printf ("  rdst = 0x%x\n", rdst);
4679                   }
4680                 SYNTAX("or      #%1, %0");
4681 #line 411 "rx-decode.opc"
4682                 ID(or); SC(IMMex(im)); DR(rdst); F("-SZ-");
4683
4684               }
4685             break;
4686           default: UNSUPPORTED(); break;
4687         }
4688       break;
4689     case 0x75:
4690         GETBYTE ();
4691         switch (op[1] & 0xff)
4692         {
4693           case 0x00:
4694           case 0x01:
4695           case 0x02:
4696           case 0x03:
4697           case 0x04:
4698           case 0x05:
4699           case 0x06:
4700           case 0x07:
4701           case 0x08:
4702           case 0x09:
4703           case 0x0a:
4704           case 0x0b:
4705           case 0x0c:
4706           case 0x0d:
4707           case 0x0e:
4708           case 0x0f:
4709             goto op_semantics_31;
4710             break;
4711           case 0x10:
4712           case 0x11:
4713           case 0x12:
4714           case 0x13:
4715           case 0x14:
4716           case 0x15:
4717           case 0x16:
4718           case 0x17:
4719           case 0x18:
4720           case 0x19:
4721           case 0x1a:
4722           case 0x1b:
4723           case 0x1c:
4724           case 0x1d:
4725           case 0x1e:
4726           case 0x1f:
4727             goto op_semantics_32;
4728             break;
4729           case 0x20:
4730           case 0x21:
4731           case 0x22:
4732           case 0x23:
4733           case 0x24:
4734           case 0x25:
4735           case 0x26:
4736           case 0x27:
4737           case 0x28:
4738           case 0x29:
4739           case 0x2a:
4740           case 0x2b:
4741           case 0x2c:
4742           case 0x2d:
4743           case 0x2e:
4744           case 0x2f:
4745             goto op_semantics_33;
4746             break;
4747           case 0x30:
4748           case 0x31:
4749           case 0x32:
4750           case 0x33:
4751           case 0x34:
4752           case 0x35:
4753           case 0x36:
4754           case 0x37:
4755           case 0x38:
4756           case 0x39:
4757           case 0x3a:
4758           case 0x3b:
4759           case 0x3c:
4760           case 0x3d:
4761           case 0x3e:
4762           case 0x3f:
4763             goto op_semantics_34;
4764             break;
4765           case 0x40:
4766           case 0x41:
4767           case 0x42:
4768           case 0x43:
4769           case 0x44:
4770           case 0x45:
4771           case 0x46:
4772           case 0x47:
4773           case 0x48:
4774           case 0x49:
4775           case 0x4a:
4776           case 0x4b:
4777           case 0x4c:
4778           case 0x4d:
4779           case 0x4e:
4780           case 0x4f:
4781               {
4782                 /** 0111 0101 0100 rdst         mov%s   #%1, %0 */
4783 #line 286 "rx-decode.opc"
4784                 int rdst AU = op[1] & 0x0f;
4785                 if (trace)
4786                   {
4787                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4788                            "/** 0111 0101 0100 rdst             mov%s   #%1, %0 */",
4789                            op[0], op[1]);
4790                     printf ("  rdst = 0x%x\n", rdst);
4791                   }
4792                 SYNTAX("mov%s   #%1, %0");
4793 #line 286 "rx-decode.opc"
4794                 ID(mov); DR(rdst); SC(IMM (1)); F("----");
4795
4796               }
4797             break;
4798           case 0x50:
4799           case 0x51:
4800           case 0x52:
4801           case 0x53:
4802           case 0x54:
4803           case 0x55:
4804           case 0x56:
4805           case 0x57:
4806           case 0x58:
4807           case 0x59:
4808           case 0x5a:
4809           case 0x5b:
4810           case 0x5c:
4811           case 0x5d:
4812           case 0x5e:
4813           case 0x5f:
4814               {
4815                 /** 0111 0101 0101 rsrc                 cmp     #%2, %1 */
4816 #line 504 "rx-decode.opc"
4817                 int rsrc AU = op[1] & 0x0f;
4818                 if (trace)
4819                   {
4820                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4821                            "/** 0111 0101 0101 rsrc                     cmp     #%2, %1 */",
4822                            op[0], op[1]);
4823                     printf ("  rsrc = 0x%x\n", rsrc);
4824                   }
4825                 SYNTAX("cmp     #%2, %1");
4826 #line 504 "rx-decode.opc"
4827                 ID(sub); SR(rsrc); S2C(IMM(1)); F("OSZC");
4828
4829               }
4830             break;
4831           case 0x60:
4832               {
4833                 /** 0111 0101 0110 0000         int #%1 */
4834                 if (trace)
4835                   {
4836                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4837                            "/** 0111 0101 0110 0000             int #%1 */",
4838                            op[0], op[1]);
4839                   }
4840                 SYNTAX("int #%1");
4841 #line 957 "rx-decode.opc"
4842                 ID(int); SC(IMM(1));
4843
4844               }
4845             break;
4846           case 0x70:
4847               GETBYTE ();
4848               switch (op[2] & 0xf0)
4849               {
4850                 case 0x00:
4851                     {
4852                       /** 0111 0101 0111 0000 0000 immm mvtipl  #%1 */
4853 #line 924 "rx-decode.opc"
4854                       int immm AU = op[2] & 0x0f;
4855                       if (trace)
4856                         {
4857                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
4858                                  "/** 0111 0101 0111 0000 0000 immm     mvtipl  #%1 */",
4859                                  op[0], op[1], op[2]);
4860                           printf ("  immm = 0x%x\n", immm);
4861                         }
4862                       SYNTAX("mvtipl    #%1");
4863 #line 924 "rx-decode.opc"
4864                       ID(mvtipl); SC(immm);
4865
4866                     }
4867                   break;
4868                 default: UNSUPPORTED(); break;
4869               }
4870             break;
4871           default: UNSUPPORTED(); break;
4872         }
4873       break;
4874     case 0x76:
4875         GETBYTE ();
4876         switch (op[1] & 0xf0)
4877         {
4878           case 0x00:
4879             goto op_semantics_31;
4880             break;
4881           case 0x10:
4882             goto op_semantics_32;
4883             break;
4884           case 0x20:
4885             goto op_semantics_33;
4886             break;
4887           case 0x30:
4888             goto op_semantics_34;
4889             break;
4890           default: UNSUPPORTED(); break;
4891         }
4892       break;
4893     case 0x77:
4894         GETBYTE ();
4895         switch (op[1] & 0xf0)
4896         {
4897           case 0x00:
4898             goto op_semantics_31;
4899             break;
4900           case 0x10:
4901             goto op_semantics_32;
4902             break;
4903           case 0x20:
4904             goto op_semantics_33;
4905             break;
4906           case 0x30:
4907             goto op_semantics_34;
4908             break;
4909           default: UNSUPPORTED(); break;
4910         }
4911       break;
4912     case 0x78:
4913         GETBYTE ();
4914         switch (op[1] & 0x00)
4915         {
4916           case 0x00:
4917             op_semantics_35:
4918               {
4919                 /** 0111 100b ittt rdst                 bset    #%1, %0 */
4920 #line 875 "rx-decode.opc"
4921                 int b AU = op[0] & 0x01;
4922 #line 875 "rx-decode.opc"
4923                 int ittt AU = (op[1] >> 4) & 0x0f;
4924 #line 875 "rx-decode.opc"
4925                 int rdst AU = op[1] & 0x0f;
4926                 if (trace)
4927                   {
4928                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4929                            "/** 0111 100b ittt rdst                     bset    #%1, %0 */",
4930                            op[0], op[1]);
4931                     printf ("  b = 0x%x,", b);
4932                     printf ("  ittt = 0x%x,", ittt);
4933                     printf ("  rdst = 0x%x\n", rdst);
4934                   }
4935                 SYNTAX("bset    #%1, %0");
4936 #line 875 "rx-decode.opc"
4937                 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F("----");
4938
4939
4940               }
4941             break;
4942         }
4943       break;
4944     case 0x79:
4945         GETBYTE ();
4946         switch (op[1] & 0x00)
4947         {
4948           case 0x00:
4949             goto op_semantics_35;
4950             break;
4951         }
4952       break;
4953     case 0x7a:
4954         GETBYTE ();
4955         switch (op[1] & 0x00)
4956         {
4957           case 0x00:
4958             op_semantics_36:
4959               {
4960                 /** 0111 101b ittt rdst                 bclr    #%1, %0 */
4961 #line 885 "rx-decode.opc"
4962                 int b AU = op[0] & 0x01;
4963 #line 885 "rx-decode.opc"
4964                 int ittt AU = (op[1] >> 4) & 0x0f;
4965 #line 885 "rx-decode.opc"
4966                 int rdst AU = op[1] & 0x0f;
4967                 if (trace)
4968                   {
4969                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4970                            "/** 0111 101b ittt rdst                     bclr    #%1, %0 */",
4971                            op[0], op[1]);
4972                     printf ("  b = 0x%x,", b);
4973                     printf ("  ittt = 0x%x,", ittt);
4974                     printf ("  rdst = 0x%x\n", rdst);
4975                   }
4976                 SYNTAX("bclr    #%1, %0");
4977 #line 885 "rx-decode.opc"
4978                 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F("----");
4979
4980
4981               }
4982             break;
4983         }
4984       break;
4985     case 0x7b:
4986         GETBYTE ();
4987         switch (op[1] & 0x00)
4988         {
4989           case 0x00:
4990             goto op_semantics_36;
4991             break;
4992         }
4993       break;
4994     case 0x7c:
4995         GETBYTE ();
4996         switch (op[1] & 0x00)
4997         {
4998           case 0x00:
4999             op_semantics_37:
5000               {
5001                 /** 0111 110b ittt rdst                 btst    #%2, %1 */
5002 #line 895 "rx-decode.opc"
5003                 int b AU = op[0] & 0x01;
5004 #line 895 "rx-decode.opc"
5005                 int ittt AU = (op[1] >> 4) & 0x0f;
5006 #line 895 "rx-decode.opc"
5007                 int rdst AU = op[1] & 0x0f;
5008                 if (trace)
5009                   {
5010                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5011                            "/** 0111 110b ittt rdst                     btst    #%2, %1 */",
5012                            op[0], op[1]);
5013                     printf ("  b = 0x%x,", b);
5014                     printf ("  ittt = 0x%x,", ittt);
5015                     printf ("  rdst = 0x%x\n", rdst);
5016                   }
5017                 SYNTAX("btst    #%2, %1");
5018 #line 895 "rx-decode.opc"
5019                 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F("--ZC");
5020
5021
5022               }
5023             break;
5024         }
5025       break;
5026     case 0x7d:
5027         GETBYTE ();
5028         switch (op[1] & 0x00)
5029         {
5030           case 0x00:
5031             goto op_semantics_37;
5032             break;
5033         }
5034       break;
5035     case 0x7e:
5036         GETBYTE ();
5037         switch (op[1] & 0xf0)
5038         {
5039           case 0x00:
5040               {
5041                 /** 0111 1110 0000 rdst                 not     %0 */
5042 #line 438 "rx-decode.opc"
5043                 int rdst AU = op[1] & 0x0f;
5044                 if (trace)
5045                   {
5046                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5047                            "/** 0111 1110 0000 rdst                     not     %0 */",
5048                            op[0], op[1]);
5049                     printf ("  rdst = 0x%x\n", rdst);
5050                   }
5051                 SYNTAX("not     %0");
5052 #line 438 "rx-decode.opc"
5053                 ID(xor); DR(rdst); SR(rdst); S2C(~0); F("-SZ-");
5054
5055               }
5056             break;
5057           case 0x10:
5058               {
5059                 /** 0111 1110 0001 rdst                 neg     %0 */
5060 #line 459 "rx-decode.opc"
5061                 int rdst AU = op[1] & 0x0f;
5062                 if (trace)
5063                   {
5064                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5065                            "/** 0111 1110 0001 rdst                     neg     %0 */",
5066                            op[0], op[1]);
5067                     printf ("  rdst = 0x%x\n", rdst);
5068                   }
5069                 SYNTAX("neg     %0");
5070 #line 459 "rx-decode.opc"
5071                 ID(sub); DR(rdst); SC(0); S2R(rdst); F("OSZC");
5072
5073               }
5074             break;
5075           case 0x20:
5076               {
5077                 /** 0111 1110 0010 rdst                 abs     %0 */
5078 #line 541 "rx-decode.opc"
5079                 int rdst AU = op[1] & 0x0f;
5080                 if (trace)
5081                   {
5082                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5083                            "/** 0111 1110 0010 rdst                     abs     %0 */",
5084                            op[0], op[1]);
5085                     printf ("  rdst = 0x%x\n", rdst);
5086                   }
5087                 SYNTAX("abs     %0");
5088 #line 541 "rx-decode.opc"
5089                 ID(abs); DR(rdst); SR(rdst); F("OSZ-");
5090
5091               }
5092             break;
5093           case 0x30:
5094               {
5095                 /** 0111 1110 0011 rdst         sat     %0 */
5096 #line 815 "rx-decode.opc"
5097                 int rdst AU = op[1] & 0x0f;
5098                 if (trace)
5099                   {
5100                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5101                            "/** 0111 1110 0011 rdst             sat     %0 */",
5102                            op[0], op[1]);
5103                     printf ("  rdst = 0x%x\n", rdst);
5104                   }
5105                 SYNTAX("sat     %0");
5106 #line 815 "rx-decode.opc"
5107                 ID(sat); DR (rdst);
5108
5109               }
5110             break;
5111           case 0x40:
5112               {
5113                 /** 0111 1110 0100 rdst                 rorc    %0 */
5114 #line 675 "rx-decode.opc"
5115                 int rdst AU = op[1] & 0x0f;
5116                 if (trace)
5117                   {
5118                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5119                            "/** 0111 1110 0100 rdst                     rorc    %0 */",
5120                            op[0], op[1]);
5121                     printf ("  rdst = 0x%x\n", rdst);
5122                   }
5123                 SYNTAX("rorc    %0");
5124 #line 675 "rx-decode.opc"
5125                 ID(rorc); DR(rdst); F("-SZC");
5126
5127               }
5128             break;
5129           case 0x50:
5130               {
5131                 /** 0111 1110 0101 rdst                 rolc    %0 */
5132 #line 672 "rx-decode.opc"
5133                 int rdst AU = op[1] & 0x0f;
5134                 if (trace)
5135                   {
5136                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5137                            "/** 0111 1110 0101 rdst                     rolc    %0 */",
5138                            op[0], op[1]);
5139                     printf ("  rdst = 0x%x\n", rdst);
5140                   }
5141                 SYNTAX("rolc    %0");
5142 #line 672 "rx-decode.opc"
5143                 ID(rolc); DR(rdst); F("-SZC");
5144
5145               }
5146             break;
5147           case 0x80:
5148           case 0x90:
5149           case 0xa0:
5150               {
5151                 /** 0111 1110 10sz rsrc         push%s  %1 */
5152 #line 354 "rx-decode.opc"
5153                 int sz AU = (op[1] >> 4) & 0x03;
5154 #line 354 "rx-decode.opc"
5155                 int rsrc AU = op[1] & 0x0f;
5156                 if (trace)
5157                   {
5158                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5159                            "/** 0111 1110 10sz rsrc             push%s  %1 */",
5160                            op[0], op[1]);
5161                     printf ("  sz = 0x%x,", sz);
5162                     printf ("  rsrc = 0x%x\n", rsrc);
5163                   }
5164                 SYNTAX("push%s  %1");
5165 #line 354 "rx-decode.opc"
5166                 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F("----");
5167
5168               }
5169             break;
5170           case 0xb0:
5171               {
5172                 /** 0111 1110 1011 rdst         pop     %0 */
5173 #line 351 "rx-decode.opc"
5174                 int rdst AU = op[1] & 0x0f;
5175                 if (trace)
5176                   {
5177                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5178                            "/** 0111 1110 1011 rdst             pop     %0 */",
5179                            op[0], op[1]);
5180                     printf ("  rdst = 0x%x\n", rdst);
5181                   }
5182                 SYNTAX("pop     %0");
5183 #line 351 "rx-decode.opc"
5184                 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F("----");
5185
5186               }
5187             break;
5188           case 0xc0:
5189           case 0xd0:
5190               {
5191                 /** 0111 1110 110 crsrc                 pushc   %1 */
5192 #line 930 "rx-decode.opc"
5193                 int crsrc AU = op[1] & 0x1f;
5194                 if (trace)
5195                   {
5196                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5197                            "/** 0111 1110 110 crsrc                     pushc   %1 */",
5198                            op[0], op[1]);
5199                     printf ("  crsrc = 0x%x\n", crsrc);
5200                   }
5201                 SYNTAX("pushc   %1");
5202 #line 930 "rx-decode.opc"
5203                 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
5204
5205               }
5206             break;
5207           case 0xe0:
5208           case 0xf0:
5209               {
5210                 /** 0111 1110 111 crdst                 popc    %0 */
5211 #line 927 "rx-decode.opc"
5212                 int crdst AU = op[1] & 0x1f;
5213                 if (trace)
5214                   {
5215                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5216                            "/** 0111 1110 111 crdst                     popc    %0 */",
5217                            op[0], op[1]);
5218                     printf ("  crdst = 0x%x\n", crdst);
5219                   }
5220                 SYNTAX("popc    %0");
5221 #line 927 "rx-decode.opc"
5222                 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
5223
5224               }
5225             break;
5226           default: UNSUPPORTED(); break;
5227         }
5228       break;
5229     case 0x7f:
5230         GETBYTE ();
5231         switch (op[1] & 0xff)
5232         {
5233           case 0x00:
5234           case 0x01:
5235           case 0x02:
5236           case 0x03:
5237           case 0x04:
5238           case 0x05:
5239           case 0x06:
5240           case 0x07:
5241           case 0x08:
5242           case 0x09:
5243           case 0x0a:
5244           case 0x0b:
5245           case 0x0c:
5246           case 0x0d:
5247           case 0x0e:
5248           case 0x0f:
5249               {
5250                 /** 0111 1111 0000 rsrc         jmp     %0 */
5251 #line 725 "rx-decode.opc"
5252                 int rsrc AU = op[1] & 0x0f;
5253                 if (trace)
5254                   {
5255                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5256                            "/** 0111 1111 0000 rsrc             jmp     %0 */",
5257                            op[0], op[1]);
5258                     printf ("  rsrc = 0x%x\n", rsrc);
5259                   }
5260                 SYNTAX("jmp     %0");
5261 #line 725 "rx-decode.opc"
5262                 ID(branch); Scc(RXC_always); DR(rsrc);
5263
5264               }
5265             break;
5266           case 0x10:
5267           case 0x11:
5268           case 0x12:
5269           case 0x13:
5270           case 0x14:
5271           case 0x15:
5272           case 0x16:
5273           case 0x17:
5274           case 0x18:
5275           case 0x19:
5276           case 0x1a:
5277           case 0x1b:
5278           case 0x1c:
5279           case 0x1d:
5280           case 0x1e:
5281           case 0x1f:
5282               {
5283                 /** 0111 1111 0001 rsrc         jsr     %0 */
5284 #line 728 "rx-decode.opc"
5285                 int rsrc AU = op[1] & 0x0f;
5286                 if (trace)
5287                   {
5288                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5289                            "/** 0111 1111 0001 rsrc             jsr     %0 */",
5290                            op[0], op[1]);
5291                     printf ("  rsrc = 0x%x\n", rsrc);
5292                   }
5293                 SYNTAX("jsr     %0");
5294 #line 728 "rx-decode.opc"
5295                 ID(jsr); DR(rsrc);
5296
5297               }
5298             break;
5299           case 0x40:
5300           case 0x41:
5301           case 0x42:
5302           case 0x43:
5303           case 0x44:
5304           case 0x45:
5305           case 0x46:
5306           case 0x47:
5307           case 0x48:
5308           case 0x49:
5309           case 0x4a:
5310           case 0x4b:
5311           case 0x4c:
5312           case 0x4d:
5313           case 0x4e:
5314           case 0x4f:
5315               {
5316                 /** 0111 1111 0100 rsrc         bra.l   %0 */
5317 #line 721 "rx-decode.opc"
5318                 int rsrc AU = op[1] & 0x0f;
5319                 if (trace)
5320                   {
5321                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5322                            "/** 0111 1111 0100 rsrc             bra.l   %0 */",
5323                            op[0], op[1]);
5324                     printf ("  rsrc = 0x%x\n", rsrc);
5325                   }
5326                 SYNTAX("bra.l   %0");
5327 #line 721 "rx-decode.opc"
5328                 ID(branchrel); Scc(RXC_always); DR(rsrc);
5329
5330
5331               }
5332             break;
5333           case 0x50:
5334           case 0x51:
5335           case 0x52:
5336           case 0x53:
5337           case 0x54:
5338           case 0x55:
5339           case 0x56:
5340           case 0x57:
5341           case 0x58:
5342           case 0x59:
5343           case 0x5a:
5344           case 0x5b:
5345           case 0x5c:
5346           case 0x5d:
5347           case 0x5e:
5348           case 0x5f:
5349               {
5350                 /** 0111 1111 0101 rsrc         bsr.l   %0 */
5351 #line 737 "rx-decode.opc"
5352                 int rsrc AU = op[1] & 0x0f;
5353                 if (trace)
5354                   {
5355                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5356                            "/** 0111 1111 0101 rsrc             bsr.l   %0 */",
5357                            op[0], op[1]);
5358                     printf ("  rsrc = 0x%x\n", rsrc);
5359                   }
5360                 SYNTAX("bsr.l   %0");
5361 #line 737 "rx-decode.opc"
5362                 ID(jsrrel); DR(rsrc);
5363
5364               }
5365             break;
5366           case 0x80:
5367           case 0x81:
5368           case 0x82:
5369               {
5370                 /** 0111 1111 1000 00sz         suntil%s */
5371 #line 761 "rx-decode.opc"
5372                 int sz AU = op[1] & 0x03;
5373                 if (trace)
5374                   {
5375                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5376                            "/** 0111 1111 1000 00sz             suntil%s */",
5377                            op[0], op[1]);
5378                     printf ("  sz = 0x%x\n", sz);
5379                   }
5380                 SYNTAX("suntil%s");
5381 #line 761 "rx-decode.opc"
5382                 ID(suntil); BWL(sz); F("--ZC");
5383
5384               }
5385             break;
5386           case 0x83:
5387               {
5388                 /** 0111 1111 1000 0011         scmpu */
5389                 if (trace)
5390                   {
5391                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5392                            "/** 0111 1111 1000 0011             scmpu */",
5393                            op[0], op[1]);
5394                   }
5395                 SYNTAX("scmpu");
5396 #line 752 "rx-decode.opc"
5397                 ID(scmpu); F("--ZC");
5398
5399               }
5400             break;
5401           case 0x84:
5402           case 0x85:
5403           case 0x86:
5404               {
5405                 /** 0111 1111 1000 01sz         swhile%s */
5406 #line 764 "rx-decode.opc"
5407                 int sz AU = op[1] & 0x03;
5408                 if (trace)
5409                   {
5410                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5411                            "/** 0111 1111 1000 01sz             swhile%s */",
5412                            op[0], op[1]);
5413                     printf ("  sz = 0x%x\n", sz);
5414                   }
5415                 SYNTAX("swhile%s");
5416 #line 764 "rx-decode.opc"
5417                 ID(swhile); BWL(sz); F("--ZC");
5418
5419               }
5420             break;
5421           case 0x87:
5422               {
5423                 /** 0111 1111 1000 0111         smovu */
5424                 if (trace)
5425                   {
5426                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5427                            "/** 0111 1111 1000 0111             smovu */",
5428                            op[0], op[1]);
5429                   }
5430                 SYNTAX("smovu");
5431 #line 755 "rx-decode.opc"
5432                 ID(smovu);
5433
5434               }
5435             break;
5436           case 0x88:
5437           case 0x89:
5438           case 0x8a:
5439               {
5440                 /** 0111 1111 1000 10sz         sstr%s */
5441 #line 770 "rx-decode.opc"
5442                 int sz AU = op[1] & 0x03;
5443                 if (trace)
5444                   {
5445                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5446                            "/** 0111 1111 1000 10sz             sstr%s */",
5447                            op[0], op[1]);
5448                     printf ("  sz = 0x%x\n", sz);
5449                   }
5450                 SYNTAX("sstr%s");
5451 #line 770 "rx-decode.opc"
5452                 ID(sstr); BWL(sz);
5453
5454               /*----------------------------------------------------------------------*/
5455               /* RMPA                                                                   */
5456
5457               }
5458             break;
5459           case 0x8b:
5460               {
5461                 /** 0111 1111 1000 1011         smovb */
5462                 if (trace)
5463                   {
5464                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5465                            "/** 0111 1111 1000 1011             smovb */",
5466                            op[0], op[1]);
5467                   }
5468                 SYNTAX("smovb");
5469 #line 758 "rx-decode.opc"
5470                 ID(smovb);
5471
5472               }
5473             break;
5474           case 0x8c:
5475           case 0x8d:
5476           case 0x8e:
5477               {
5478                 /** 0111 1111 1000 11sz         rmpa%s */
5479 #line 776 "rx-decode.opc"
5480                 int sz AU = op[1] & 0x03;
5481                 if (trace)
5482                   {
5483                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5484                            "/** 0111 1111 1000 11sz             rmpa%s */",
5485                            op[0], op[1]);
5486                     printf ("  sz = 0x%x\n", sz);
5487                   }
5488                 SYNTAX("rmpa%s");
5489 #line 776 "rx-decode.opc"
5490                 ID(rmpa); BWL(sz); F("OS--");
5491
5492               /*----------------------------------------------------------------------*/
5493               /* HI/LO stuff                                                            */
5494
5495               }
5496             break;
5497           case 0x8f:
5498               {
5499                 /** 0111 1111 1000 1111         smovf */
5500                 if (trace)
5501                   {
5502                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5503                            "/** 0111 1111 1000 1111             smovf */",
5504                            op[0], op[1]);
5505                   }
5506                 SYNTAX("smovf");
5507 #line 767 "rx-decode.opc"
5508                 ID(smovf);
5509
5510               }
5511             break;
5512           case 0x93:
5513               {
5514                 /** 0111 1111 1001 0011         satr */
5515                 if (trace)
5516                   {
5517                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5518                            "/** 0111 1111 1001 0011             satr */",
5519                            op[0], op[1]);
5520                   }
5521                 SYNTAX("satr");
5522 #line 818 "rx-decode.opc"
5523                 ID(satr);
5524
5525               /*----------------------------------------------------------------------*/
5526               /* FLOAT                                                          */
5527
5528               }
5529             break;
5530           case 0x94:
5531               {
5532                 /** 0111 1111 1001 0100         rtfi */
5533                 if (trace)
5534                   {
5535                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5536                            "/** 0111 1111 1001 0100             rtfi */",
5537                            op[0], op[1]);
5538                   }
5539                 SYNTAX("rtfi");
5540 #line 945 "rx-decode.opc"
5541                 ID(rtfi);
5542
5543               }
5544             break;
5545           case 0x95:
5546               {
5547                 /** 0111 1111 1001 0101         rte */
5548                 if (trace)
5549                   {
5550                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5551                            "/** 0111 1111 1001 0101             rte */",
5552                            op[0], op[1]);
5553                   }
5554                 SYNTAX("rte");
5555 #line 948 "rx-decode.opc"
5556                 ID(rte);
5557
5558               }
5559             break;
5560           case 0x96:
5561               {
5562                 /** 0111 1111 1001 0110         wait */
5563                 if (trace)
5564                   {
5565                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5566                            "/** 0111 1111 1001 0110             wait */",
5567                            op[0], op[1]);
5568                   }
5569                 SYNTAX("wait");
5570 #line 960 "rx-decode.opc"
5571                 ID(wait);
5572
5573               /*----------------------------------------------------------------------*/
5574               /* SCcnd                                                          */
5575
5576               }
5577             break;
5578           case 0xa0:
5579           case 0xa1:
5580           case 0xa2:
5581           case 0xa3:
5582           case 0xa4:
5583           case 0xa5:
5584           case 0xa6:
5585           case 0xa7:
5586           case 0xa8:
5587           case 0xa9:
5588           case 0xaa:
5589           case 0xab:
5590           case 0xac:
5591           case 0xad:
5592           case 0xae:
5593           case 0xaf:
5594               {
5595                 /** 0111 1111 1010 rdst                 setpsw  %0 */
5596 #line 921 "rx-decode.opc"
5597                 int rdst AU = op[1] & 0x0f;
5598                 if (trace)
5599                   {
5600                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5601                            "/** 0111 1111 1010 rdst                     setpsw  %0 */",
5602                            op[0], op[1]);
5603                     printf ("  rdst = 0x%x\n", rdst);
5604                   }
5605                 SYNTAX("setpsw  %0");
5606 #line 921 "rx-decode.opc"
5607                 ID(setpsw); DF(rdst);
5608
5609               }
5610             break;
5611           case 0xb0:
5612           case 0xb1:
5613           case 0xb2:
5614           case 0xb3:
5615           case 0xb4:
5616           case 0xb5:
5617           case 0xb6:
5618           case 0xb7:
5619           case 0xb8:
5620           case 0xb9:
5621           case 0xba:
5622           case 0xbb:
5623           case 0xbc:
5624           case 0xbd:
5625           case 0xbe:
5626           case 0xbf:
5627               {
5628                 /** 0111 1111 1011 rdst                 clrpsw  %0 */
5629 #line 918 "rx-decode.opc"
5630                 int rdst AU = op[1] & 0x0f;
5631                 if (trace)
5632                   {
5633                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5634                            "/** 0111 1111 1011 rdst                     clrpsw  %0 */",
5635                            op[0], op[1]);
5636                     printf ("  rdst = 0x%x\n", rdst);
5637                   }
5638                 SYNTAX("clrpsw  %0");
5639 #line 918 "rx-decode.opc"
5640                 ID(clrpsw); DF(rdst);
5641
5642               }
5643             break;
5644           default: UNSUPPORTED(); break;
5645         }
5646       break;
5647     case 0x80:
5648         GETBYTE ();
5649         switch (op[1] & 0x00)
5650         {
5651           case 0x00:
5652             op_semantics_38:
5653               {
5654                 /** 10sz 0dsp a dst b src       mov%s   %1, %0 */
5655 #line 312 "rx-decode.opc"
5656                 int sz AU = (op[0] >> 4) & 0x03;
5657 #line 312 "rx-decode.opc"
5658                 int dsp AU = op[0] & 0x07;
5659 #line 312 "rx-decode.opc"
5660                 int a AU = (op[1] >> 7) & 0x01;
5661 #line 312 "rx-decode.opc"
5662                 int dst AU = (op[1] >> 4) & 0x07;
5663 #line 312 "rx-decode.opc"
5664                 int b AU = (op[1] >> 3) & 0x01;
5665 #line 312 "rx-decode.opc"
5666                 int src AU = op[1] & 0x07;
5667                 if (trace)
5668                   {
5669                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5670                            "/** 10sz 0dsp a dst b src   mov%s   %1, %0 */",
5671                            op[0], op[1]);
5672                     printf ("  sz = 0x%x,", sz);
5673                     printf ("  dsp = 0x%x,", dsp);
5674                     printf ("  a = 0x%x,", a);
5675                     printf ("  dst = 0x%x,", dst);
5676                     printf ("  b = 0x%x,", b);
5677                     printf ("  src = 0x%x\n", src);
5678                   }
5679                 SYNTAX("mov%s   %1, %0");
5680 #line 312 "rx-decode.opc"
5681                 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F("----");
5682
5683               }
5684             break;
5685         }
5686       break;
5687     case 0x81:
5688         GETBYTE ();
5689         switch (op[1] & 0x00)
5690         {
5691           case 0x00:
5692             goto op_semantics_38;
5693             break;
5694         }
5695       break;
5696     case 0x82:
5697         GETBYTE ();
5698         switch (op[1] & 0x00)
5699         {
5700           case 0x00:
5701             goto op_semantics_38;
5702             break;
5703         }
5704       break;
5705     case 0x83:
5706         GETBYTE ();
5707         switch (op[1] & 0x00)
5708         {
5709           case 0x00:
5710             goto op_semantics_38;
5711             break;
5712         }
5713       break;
5714     case 0x84:
5715         GETBYTE ();
5716         switch (op[1] & 0x00)
5717         {
5718           case 0x00:
5719             goto op_semantics_38;
5720             break;
5721         }
5722       break;
5723     case 0x85:
5724         GETBYTE ();
5725         switch (op[1] & 0x00)
5726         {
5727           case 0x00:
5728             goto op_semantics_38;
5729             break;
5730         }
5731       break;
5732     case 0x86:
5733         GETBYTE ();
5734         switch (op[1] & 0x00)
5735         {
5736           case 0x00:
5737             goto op_semantics_38;
5738             break;
5739         }
5740       break;
5741     case 0x87:
5742         GETBYTE ();
5743         switch (op[1] & 0x00)
5744         {
5745           case 0x00:
5746             goto op_semantics_38;
5747             break;
5748         }
5749       break;
5750     case 0x88:
5751         GETBYTE ();
5752         switch (op[1] & 0x00)
5753         {
5754           case 0x00:
5755             op_semantics_39:
5756               {
5757                 /** 10sz 1dsp a src b dst       mov%s   %1, %0 */
5758 #line 309 "rx-decode.opc"
5759                 int sz AU = (op[0] >> 4) & 0x03;
5760 #line 309 "rx-decode.opc"
5761                 int dsp AU = op[0] & 0x07;
5762 #line 309 "rx-decode.opc"
5763                 int a AU = (op[1] >> 7) & 0x01;
5764 #line 309 "rx-decode.opc"
5765                 int src AU = (op[1] >> 4) & 0x07;
5766 #line 309 "rx-decode.opc"
5767                 int b AU = (op[1] >> 3) & 0x01;
5768 #line 309 "rx-decode.opc"
5769                 int dst AU = op[1] & 0x07;
5770                 if (trace)
5771                   {
5772                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5773                            "/** 10sz 1dsp a src b dst   mov%s   %1, %0 */",
5774                            op[0], op[1]);
5775                     printf ("  sz = 0x%x,", sz);
5776                     printf ("  dsp = 0x%x,", dsp);
5777                     printf ("  a = 0x%x,", a);
5778                     printf ("  src = 0x%x,", src);
5779                     printf ("  b = 0x%x,", b);
5780                     printf ("  dst = 0x%x\n", dst);
5781                   }
5782                 SYNTAX("mov%s   %1, %0");
5783 #line 309 "rx-decode.opc"
5784                 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F("----");
5785
5786               }
5787             break;
5788         }
5789       break;
5790     case 0x89:
5791         GETBYTE ();
5792         switch (op[1] & 0x00)
5793         {
5794           case 0x00:
5795             goto op_semantics_39;
5796             break;
5797         }
5798       break;
5799     case 0x8a:
5800         GETBYTE ();
5801         switch (op[1] & 0x00)
5802         {
5803           case 0x00:
5804             goto op_semantics_39;
5805             break;
5806         }
5807       break;
5808     case 0x8b:
5809         GETBYTE ();
5810         switch (op[1] & 0x00)
5811         {
5812           case 0x00:
5813             goto op_semantics_39;
5814             break;
5815         }
5816       break;
5817     case 0x8c:
5818         GETBYTE ();
5819         switch (op[1] & 0x00)
5820         {
5821           case 0x00:
5822             goto op_semantics_39;
5823             break;
5824         }
5825       break;
5826     case 0x8d:
5827         GETBYTE ();
5828         switch (op[1] & 0x00)
5829         {
5830           case 0x00:
5831             goto op_semantics_39;
5832             break;
5833         }
5834       break;
5835     case 0x8e:
5836         GETBYTE ();
5837         switch (op[1] & 0x00)
5838         {
5839           case 0x00:
5840             goto op_semantics_39;
5841             break;
5842         }
5843       break;
5844     case 0x8f:
5845         GETBYTE ();
5846         switch (op[1] & 0x00)
5847         {
5848           case 0x00:
5849             goto op_semantics_39;
5850             break;
5851         }
5852       break;
5853     case 0x90:
5854         GETBYTE ();
5855         switch (op[1] & 0x00)
5856         {
5857           case 0x00:
5858             goto op_semantics_38;
5859             break;
5860         }
5861       break;
5862     case 0x91:
5863         GETBYTE ();
5864         switch (op[1] & 0x00)
5865         {
5866           case 0x00:
5867             goto op_semantics_38;
5868             break;
5869         }
5870       break;
5871     case 0x92:
5872         GETBYTE ();
5873         switch (op[1] & 0x00)
5874         {
5875           case 0x00:
5876             goto op_semantics_38;
5877             break;
5878         }
5879       break;
5880     case 0x93:
5881         GETBYTE ();
5882         switch (op[1] & 0x00)
5883         {
5884           case 0x00:
5885             goto op_semantics_38;
5886             break;
5887         }
5888       break;
5889     case 0x94:
5890         GETBYTE ();
5891         switch (op[1] & 0x00)
5892         {
5893           case 0x00:
5894             goto op_semantics_38;
5895             break;
5896         }
5897       break;
5898     case 0x95:
5899         GETBYTE ();
5900         switch (op[1] & 0x00)
5901         {
5902           case 0x00:
5903             goto op_semantics_38;
5904             break;
5905         }
5906       break;
5907     case 0x96:
5908         GETBYTE ();
5909         switch (op[1] & 0x00)
5910         {
5911           case 0x00:
5912             goto op_semantics_38;
5913             break;
5914         }
5915       break;
5916     case 0x97:
5917         GETBYTE ();
5918         switch (op[1] & 0x00)
5919         {
5920           case 0x00:
5921             goto op_semantics_38;
5922             break;
5923         }
5924       break;
5925     case 0x98:
5926         GETBYTE ();
5927         switch (op[1] & 0x00)
5928         {
5929           case 0x00:
5930             goto op_semantics_39;
5931             break;
5932         }
5933       break;
5934     case 0x99:
5935         GETBYTE ();
5936         switch (op[1] & 0x00)
5937         {
5938           case 0x00:
5939             goto op_semantics_39;
5940             break;
5941         }
5942       break;
5943     case 0x9a:
5944         GETBYTE ();
5945         switch (op[1] & 0x00)
5946         {
5947           case 0x00:
5948             goto op_semantics_39;
5949             break;
5950         }
5951       break;
5952     case 0x9b:
5953         GETBYTE ();
5954         switch (op[1] & 0x00)
5955         {
5956           case 0x00:
5957             goto op_semantics_39;
5958             break;
5959         }
5960       break;
5961     case 0x9c:
5962         GETBYTE ();
5963         switch (op[1] & 0x00)
5964         {
5965           case 0x00:
5966             goto op_semantics_39;
5967             break;
5968         }
5969       break;
5970     case 0x9d:
5971         GETBYTE ();
5972         switch (op[1] & 0x00)
5973         {
5974           case 0x00:
5975             goto op_semantics_39;
5976             break;
5977         }
5978       break;
5979     case 0x9e:
5980         GETBYTE ();
5981         switch (op[1] & 0x00)
5982         {
5983           case 0x00:
5984             goto op_semantics_39;
5985             break;
5986         }
5987       break;
5988     case 0x9f:
5989         GETBYTE ();
5990         switch (op[1] & 0x00)
5991         {
5992           case 0x00:
5993             goto op_semantics_39;
5994             break;
5995         }
5996       break;
5997     case 0xa0:
5998         GETBYTE ();
5999         switch (op[1] & 0x00)
6000         {
6001           case 0x00:
6002             goto op_semantics_38;
6003             break;
6004         }
6005       break;
6006     case 0xa1:
6007         GETBYTE ();
6008         switch (op[1] & 0x00)
6009         {
6010           case 0x00:
6011             goto op_semantics_38;
6012             break;
6013         }
6014       break;
6015     case 0xa2:
6016         GETBYTE ();
6017         switch (op[1] & 0x00)
6018         {
6019           case 0x00:
6020             goto op_semantics_38;
6021             break;
6022         }
6023       break;
6024     case 0xa3:
6025         GETBYTE ();
6026         switch (op[1] & 0x00)
6027         {
6028           case 0x00:
6029             goto op_semantics_38;
6030             break;
6031         }
6032       break;
6033     case 0xa4:
6034         GETBYTE ();
6035         switch (op[1] & 0x00)
6036         {
6037           case 0x00:
6038             goto op_semantics_38;
6039             break;
6040         }
6041       break;
6042     case 0xa5:
6043         GETBYTE ();
6044         switch (op[1] & 0x00)
6045         {
6046           case 0x00:
6047             goto op_semantics_38;
6048             break;
6049         }
6050       break;
6051     case 0xa6:
6052         GETBYTE ();
6053         switch (op[1] & 0x00)
6054         {
6055           case 0x00:
6056             goto op_semantics_38;
6057             break;
6058         }
6059       break;
6060     case 0xa7:
6061         GETBYTE ();
6062         switch (op[1] & 0x00)
6063         {
6064           case 0x00:
6065             goto op_semantics_38;
6066             break;
6067         }
6068       break;
6069     case 0xa8:
6070         GETBYTE ();
6071         switch (op[1] & 0x00)
6072         {
6073           case 0x00:
6074             goto op_semantics_39;
6075             break;
6076         }
6077       break;
6078     case 0xa9:
6079         GETBYTE ();
6080         switch (op[1] & 0x00)
6081         {
6082           case 0x00:
6083             goto op_semantics_39;
6084             break;
6085         }
6086       break;
6087     case 0xaa:
6088         GETBYTE ();
6089         switch (op[1] & 0x00)
6090         {
6091           case 0x00:
6092             goto op_semantics_39;
6093             break;
6094         }
6095       break;
6096     case 0xab:
6097         GETBYTE ();
6098         switch (op[1] & 0x00)
6099         {
6100           case 0x00:
6101             goto op_semantics_39;
6102             break;
6103         }
6104       break;
6105     case 0xac:
6106         GETBYTE ();
6107         switch (op[1] & 0x00)
6108         {
6109           case 0x00:
6110             goto op_semantics_39;
6111             break;
6112         }
6113       break;
6114     case 0xad:
6115         GETBYTE ();
6116         switch (op[1] & 0x00)
6117         {
6118           case 0x00:
6119             goto op_semantics_39;
6120             break;
6121         }
6122       break;
6123     case 0xae:
6124         GETBYTE ();
6125         switch (op[1] & 0x00)
6126         {
6127           case 0x00:
6128             goto op_semantics_39;
6129             break;
6130         }
6131       break;
6132     case 0xaf:
6133         GETBYTE ();
6134         switch (op[1] & 0x00)
6135         {
6136           case 0x00:
6137             goto op_semantics_39;
6138             break;
6139         }
6140       break;
6141     case 0xb0:
6142         GETBYTE ();
6143         switch (op[1] & 0x00)
6144         {
6145           case 0x00:
6146             op_semantics_40:
6147               {
6148                 /** 1011 w dsp a src b dst      movu%s  %1, %0 */
6149 #line 332 "rx-decode.opc"
6150                 int w AU = (op[0] >> 3) & 0x01;
6151 #line 332 "rx-decode.opc"
6152                 int dsp AU = op[0] & 0x07;
6153 #line 332 "rx-decode.opc"
6154                 int a AU = (op[1] >> 7) & 0x01;
6155 #line 332 "rx-decode.opc"
6156                 int src AU = (op[1] >> 4) & 0x07;
6157 #line 332 "rx-decode.opc"
6158                 int b AU = (op[1] >> 3) & 0x01;
6159 #line 332 "rx-decode.opc"
6160                 int dst AU = op[1] & 0x07;
6161                 if (trace)
6162                   {
6163                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6164                            "/** 1011 w dsp a src b dst  movu%s  %1, %0 */",
6165                            op[0], op[1]);
6166                     printf ("  w = 0x%x,", w);
6167                     printf ("  dsp = 0x%x,", dsp);
6168                     printf ("  a = 0x%x,", a);
6169                     printf ("  src = 0x%x,", src);
6170                     printf ("  b = 0x%x,", b);
6171                     printf ("  dst = 0x%x\n", dst);
6172                   }
6173                 SYNTAX("movu%s  %1, %0");
6174 #line 332 "rx-decode.opc"
6175                 ID(mov); uBWL(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F("----");
6176
6177               }
6178             break;
6179         }
6180       break;
6181     case 0xb1:
6182         GETBYTE ();
6183         switch (op[1] & 0x00)
6184         {
6185           case 0x00:
6186             goto op_semantics_40;
6187             break;
6188         }
6189       break;
6190     case 0xb2:
6191         GETBYTE ();
6192         switch (op[1] & 0x00)
6193         {
6194           case 0x00:
6195             goto op_semantics_40;
6196             break;
6197         }
6198       break;
6199     case 0xb3:
6200         GETBYTE ();
6201         switch (op[1] & 0x00)
6202         {
6203           case 0x00:
6204             goto op_semantics_40;
6205             break;
6206         }
6207       break;
6208     case 0xb4:
6209         GETBYTE ();
6210         switch (op[1] & 0x00)
6211         {
6212           case 0x00:
6213             goto op_semantics_40;
6214             break;
6215         }
6216       break;
6217     case 0xb5:
6218         GETBYTE ();
6219         switch (op[1] & 0x00)
6220         {
6221           case 0x00:
6222             goto op_semantics_40;
6223             break;
6224         }
6225       break;
6226     case 0xb6:
6227         GETBYTE ();
6228         switch (op[1] & 0x00)
6229         {
6230           case 0x00:
6231             goto op_semantics_40;
6232             break;
6233         }
6234       break;
6235     case 0xb7:
6236         GETBYTE ();
6237         switch (op[1] & 0x00)
6238         {
6239           case 0x00:
6240             goto op_semantics_40;
6241             break;
6242         }
6243       break;
6244     case 0xb8:
6245         GETBYTE ();
6246         switch (op[1] & 0x00)
6247         {
6248           case 0x00:
6249             goto op_semantics_40;
6250             break;
6251         }
6252       break;
6253     case 0xb9:
6254         GETBYTE ();
6255         switch (op[1] & 0x00)
6256         {
6257           case 0x00:
6258             goto op_semantics_40;
6259             break;
6260         }
6261       break;
6262     case 0xba:
6263         GETBYTE ();
6264         switch (op[1] & 0x00)
6265         {
6266           case 0x00:
6267             goto op_semantics_40;
6268             break;
6269         }
6270       break;
6271     case 0xbb:
6272         GETBYTE ();
6273         switch (op[1] & 0x00)
6274         {
6275           case 0x00:
6276             goto op_semantics_40;
6277             break;
6278         }
6279       break;
6280     case 0xbc:
6281         GETBYTE ();
6282         switch (op[1] & 0x00)
6283         {
6284           case 0x00:
6285             goto op_semantics_40;
6286             break;
6287         }
6288       break;
6289     case 0xbd:
6290         GETBYTE ();
6291         switch (op[1] & 0x00)
6292         {
6293           case 0x00:
6294             goto op_semantics_40;
6295             break;
6296         }
6297       break;
6298     case 0xbe:
6299         GETBYTE ();
6300         switch (op[1] & 0x00)
6301         {
6302           case 0x00:
6303             goto op_semantics_40;
6304             break;
6305         }
6306       break;
6307     case 0xbf:
6308         GETBYTE ();
6309         switch (op[1] & 0x00)
6310         {
6311           case 0x00:
6312             goto op_semantics_40;
6313             break;
6314         }
6315       break;
6316     case 0xc0:
6317         GETBYTE ();
6318         switch (op[1] & 0x00)
6319         {
6320           case 0x00:
6321             op_semantics_41:
6322               {
6323                 /** 11sz sd ss rsrc rdst        mov%s   %1, %0 */
6324 #line 298 "rx-decode.opc"
6325                 int sz AU = (op[0] >> 4) & 0x03;
6326 #line 298 "rx-decode.opc"
6327                 int sd AU = (op[0] >> 2) & 0x03;
6328 #line 298 "rx-decode.opc"
6329                 int ss AU = op[0] & 0x03;
6330 #line 298 "rx-decode.opc"
6331                 int rsrc AU = (op[1] >> 4) & 0x0f;
6332 #line 298 "rx-decode.opc"
6333                 int rdst AU = op[1] & 0x0f;
6334                 if (trace)
6335                   {
6336                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6337                            "/** 11sz sd ss rsrc rdst    mov%s   %1, %0 */",
6338                            op[0], op[1]);
6339                     printf ("  sz = 0x%x,", sz);
6340                     printf ("  sd = 0x%x,", sd);
6341                     printf ("  ss = 0x%x,", ss);
6342                     printf ("  rsrc = 0x%x,", rsrc);
6343                     printf ("  rdst = 0x%x\n", rdst);
6344                   }
6345                 SYNTAX("mov%s   %1, %0");
6346 #line 298 "rx-decode.opc"
6347                 ID(mov); sBWL(sz); F("----");
6348                 if ((ss == 3) && (sd != 3))
6349                   {
6350                     SD(ss, rdst, sz); DD(sd, rsrc, sz);
6351                   }
6352                 else
6353                   {
6354                     SD(ss, rsrc, sz); DD(sd, rdst, sz);
6355                   }
6356
6357               }
6358             break;
6359         }
6360       break;
6361     case 0xc1:
6362         GETBYTE ();
6363         switch (op[1] & 0x00)
6364         {
6365           case 0x00:
6366             goto op_semantics_41;
6367             break;
6368         }
6369       break;
6370     case 0xc2:
6371         GETBYTE ();
6372         switch (op[1] & 0x00)
6373         {
6374           case 0x00:
6375             goto op_semantics_41;
6376             break;
6377         }
6378       break;
6379     case 0xc3:
6380         GETBYTE ();
6381         switch (op[1] & 0x00)
6382         {
6383           case 0x00:
6384             goto op_semantics_41;
6385             break;
6386         }
6387       break;
6388     case 0xc4:
6389         GETBYTE ();
6390         switch (op[1] & 0x00)
6391         {
6392           case 0x00:
6393             goto op_semantics_41;
6394             break;
6395         }
6396       break;
6397     case 0xc5:
6398         GETBYTE ();
6399         switch (op[1] & 0x00)
6400         {
6401           case 0x00:
6402             goto op_semantics_41;
6403             break;
6404         }
6405       break;
6406     case 0xc6:
6407         GETBYTE ();
6408         switch (op[1] & 0x00)
6409         {
6410           case 0x00:
6411             goto op_semantics_41;
6412             break;
6413         }
6414       break;
6415     case 0xc7:
6416         GETBYTE ();
6417         switch (op[1] & 0x00)
6418         {
6419           case 0x00:
6420             goto op_semantics_41;
6421             break;
6422         }
6423       break;
6424     case 0xc8:
6425         GETBYTE ();
6426         switch (op[1] & 0x00)
6427         {
6428           case 0x00:
6429             goto op_semantics_41;
6430             break;
6431         }
6432       break;
6433     case 0xc9:
6434         GETBYTE ();
6435         switch (op[1] & 0x00)
6436         {
6437           case 0x00:
6438             goto op_semantics_41;
6439             break;
6440         }
6441       break;
6442     case 0xca:
6443         GETBYTE ();
6444         switch (op[1] & 0x00)
6445         {
6446           case 0x00:
6447             goto op_semantics_41;
6448             break;
6449         }
6450       break;
6451     case 0xcb:
6452         GETBYTE ();
6453         switch (op[1] & 0x00)
6454         {
6455           case 0x00:
6456             goto op_semantics_41;
6457             break;
6458         }
6459       break;
6460     case 0xcc:
6461         GETBYTE ();
6462         switch (op[1] & 0x00)
6463         {
6464           case 0x00:
6465             goto op_semantics_41;
6466             break;
6467         }
6468       break;
6469     case 0xcd:
6470         GETBYTE ();
6471         switch (op[1] & 0x00)
6472         {
6473           case 0x00:
6474             goto op_semantics_41;
6475             break;
6476         }
6477       break;
6478     case 0xce:
6479         GETBYTE ();
6480         switch (op[1] & 0x00)
6481         {
6482           case 0x00:
6483             goto op_semantics_41;
6484             break;
6485         }
6486       break;
6487     case 0xcf:
6488         GETBYTE ();
6489         switch (op[1] & 0x00)
6490         {
6491           case 0x00:
6492             goto op_semantics_41;
6493             break;
6494         }
6495       break;
6496     case 0xd0:
6497         GETBYTE ();
6498         switch (op[1] & 0x00)
6499         {
6500           case 0x00:
6501             goto op_semantics_41;
6502             break;
6503         }
6504       break;
6505     case 0xd1:
6506         GETBYTE ();
6507         switch (op[1] & 0x00)
6508         {
6509           case 0x00:
6510             goto op_semantics_41;
6511             break;
6512         }
6513       break;
6514     case 0xd2:
6515         GETBYTE ();
6516         switch (op[1] & 0x00)
6517         {
6518           case 0x00:
6519             goto op_semantics_41;
6520             break;
6521         }
6522       break;
6523     case 0xd3:
6524         GETBYTE ();
6525         switch (op[1] & 0x00)
6526         {
6527           case 0x00:
6528             goto op_semantics_41;
6529             break;
6530         }
6531       break;
6532     case 0xd4:
6533         GETBYTE ();
6534         switch (op[1] & 0x00)
6535         {
6536           case 0x00:
6537             goto op_semantics_41;
6538             break;
6539         }
6540       break;
6541     case 0xd5:
6542         GETBYTE ();
6543         switch (op[1] & 0x00)
6544         {
6545           case 0x00:
6546             goto op_semantics_41;
6547             break;
6548         }
6549       break;
6550     case 0xd6:
6551         GETBYTE ();
6552         switch (op[1] & 0x00)
6553         {
6554           case 0x00:
6555             goto op_semantics_41;
6556             break;
6557         }
6558       break;
6559     case 0xd7:
6560         GETBYTE ();
6561         switch (op[1] & 0x00)
6562         {
6563           case 0x00:
6564             goto op_semantics_41;
6565             break;
6566         }
6567       break;
6568     case 0xd8:
6569         GETBYTE ();
6570         switch (op[1] & 0x00)
6571         {
6572           case 0x00:
6573             goto op_semantics_41;
6574             break;
6575         }
6576       break;
6577     case 0xd9:
6578         GETBYTE ();
6579         switch (op[1] & 0x00)
6580         {
6581           case 0x00:
6582             goto op_semantics_41;
6583             break;
6584         }
6585       break;
6586     case 0xda:
6587         GETBYTE ();
6588         switch (op[1] & 0x00)
6589         {
6590           case 0x00:
6591             goto op_semantics_41;
6592             break;
6593         }
6594       break;
6595     case 0xdb:
6596         GETBYTE ();
6597         switch (op[1] & 0x00)
6598         {
6599           case 0x00:
6600             goto op_semantics_41;
6601             break;
6602         }
6603       break;
6604     case 0xdc:
6605         GETBYTE ();
6606         switch (op[1] & 0x00)
6607         {
6608           case 0x00:
6609             goto op_semantics_41;
6610             break;
6611         }
6612       break;
6613     case 0xdd:
6614         GETBYTE ();
6615         switch (op[1] & 0x00)
6616         {
6617           case 0x00:
6618             goto op_semantics_41;
6619             break;
6620         }
6621       break;
6622     case 0xde:
6623         GETBYTE ();
6624         switch (op[1] & 0x00)
6625         {
6626           case 0x00:
6627             goto op_semantics_41;
6628             break;
6629         }
6630       break;
6631     case 0xdf:
6632         GETBYTE ();
6633         switch (op[1] & 0x00)
6634         {
6635           case 0x00:
6636             goto op_semantics_41;
6637             break;
6638         }
6639       break;
6640     case 0xe0:
6641         GETBYTE ();
6642         switch (op[1] & 0x00)
6643         {
6644           case 0x00:
6645             goto op_semantics_41;
6646             break;
6647         }
6648       break;
6649     case 0xe1:
6650         GETBYTE ();
6651         switch (op[1] & 0x00)
6652         {
6653           case 0x00:
6654             goto op_semantics_41;
6655             break;
6656         }
6657       break;
6658     case 0xe2:
6659         GETBYTE ();
6660         switch (op[1] & 0x00)
6661         {
6662           case 0x00:
6663             goto op_semantics_41;
6664             break;
6665         }
6666       break;
6667     case 0xe3:
6668         GETBYTE ();
6669         switch (op[1] & 0x00)
6670         {
6671           case 0x00:
6672             goto op_semantics_41;
6673             break;
6674         }
6675       break;
6676     case 0xe4:
6677         GETBYTE ();
6678         switch (op[1] & 0x00)
6679         {
6680           case 0x00:
6681             goto op_semantics_41;
6682             break;
6683         }
6684       break;
6685     case 0xe5:
6686         GETBYTE ();
6687         switch (op[1] & 0x00)
6688         {
6689           case 0x00:
6690             goto op_semantics_41;
6691             break;
6692         }
6693       break;
6694     case 0xe6:
6695         GETBYTE ();
6696         switch (op[1] & 0x00)
6697         {
6698           case 0x00:
6699             goto op_semantics_41;
6700             break;
6701         }
6702       break;
6703     case 0xe7:
6704         GETBYTE ();
6705         switch (op[1] & 0x00)
6706         {
6707           case 0x00:
6708             goto op_semantics_41;
6709             break;
6710         }
6711       break;
6712     case 0xe8:
6713         GETBYTE ();
6714         switch (op[1] & 0x00)
6715         {
6716           case 0x00:
6717             goto op_semantics_41;
6718             break;
6719         }
6720       break;
6721     case 0xe9:
6722         GETBYTE ();
6723         switch (op[1] & 0x00)
6724         {
6725           case 0x00:
6726             goto op_semantics_41;
6727             break;
6728         }
6729       break;
6730     case 0xea:
6731         GETBYTE ();
6732         switch (op[1] & 0x00)
6733         {
6734           case 0x00:
6735             goto op_semantics_41;
6736             break;
6737         }
6738       break;
6739     case 0xeb:
6740         GETBYTE ();
6741         switch (op[1] & 0x00)
6742         {
6743           case 0x00:
6744             goto op_semantics_41;
6745             break;
6746         }
6747       break;
6748     case 0xec:
6749         GETBYTE ();
6750         switch (op[1] & 0x00)
6751         {
6752           case 0x00:
6753             goto op_semantics_41;
6754             break;
6755         }
6756       break;
6757     case 0xed:
6758         GETBYTE ();
6759         switch (op[1] & 0x00)
6760         {
6761           case 0x00:
6762             goto op_semantics_41;
6763             break;
6764         }
6765       break;
6766     case 0xee:
6767         GETBYTE ();
6768         switch (op[1] & 0x00)
6769         {
6770           case 0x00:
6771             goto op_semantics_41;
6772             break;
6773         }
6774       break;
6775     case 0xef:
6776         GETBYTE ();
6777         switch (op[1] & 0x00)
6778         {
6779           case 0x00:
6780             goto op_semantics_41;
6781             break;
6782         }
6783       break;
6784     case 0xf0:
6785         GETBYTE ();
6786         switch (op[1] & 0x08)
6787         {
6788           case 0x00:
6789             op_semantics_42:
6790               {
6791                 /** 1111 00sd rdst 0bit                 bset    #%1, %0%S0 */
6792 #line 869 "rx-decode.opc"
6793                 int sd AU = op[0] & 0x03;
6794 #line 869 "rx-decode.opc"
6795                 int rdst AU = (op[1] >> 4) & 0x0f;
6796 #line 869 "rx-decode.opc"
6797                 int bit AU = op[1] & 0x07;
6798                 if (trace)
6799                   {
6800                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6801                            "/** 1111 00sd rdst 0bit                     bset    #%1, %0%S0 */",
6802                            op[0], op[1]);
6803                     printf ("  sd = 0x%x,", sd);
6804                     printf ("  rdst = 0x%x,", rdst);
6805                     printf ("  bit = 0x%x\n", bit);
6806                   }
6807                 SYNTAX("bset    #%1, %0%S0");
6808 #line 869 "rx-decode.opc"
6809                 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F("----");
6810
6811               }
6812             break;
6813           case 0x08:
6814             op_semantics_43:
6815               {
6816                 /** 1111 00sd rdst 1bit                 bclr    #%1, %0%S0 */
6817 #line 879 "rx-decode.opc"
6818                 int sd AU = op[0] & 0x03;
6819 #line 879 "rx-decode.opc"
6820                 int rdst AU = (op[1] >> 4) & 0x0f;
6821 #line 879 "rx-decode.opc"
6822                 int bit AU = op[1] & 0x07;
6823                 if (trace)
6824                   {
6825                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6826                            "/** 1111 00sd rdst 1bit                     bclr    #%1, %0%S0 */",
6827                            op[0], op[1]);
6828                     printf ("  sd = 0x%x,", sd);
6829                     printf ("  rdst = 0x%x,", rdst);
6830                     printf ("  bit = 0x%x\n", bit);
6831                   }
6832                 SYNTAX("bclr    #%1, %0%S0");
6833 #line 879 "rx-decode.opc"
6834                 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F("----");
6835
6836               }
6837             break;
6838         }
6839       break;
6840     case 0xf1:
6841         GETBYTE ();
6842         switch (op[1] & 0x08)
6843         {
6844           case 0x00:
6845             goto op_semantics_42;
6846             break;
6847           case 0x08:
6848             goto op_semantics_43;
6849             break;
6850         }
6851       break;
6852     case 0xf2:
6853         GETBYTE ();
6854         switch (op[1] & 0x08)
6855         {
6856           case 0x00:
6857             goto op_semantics_42;
6858             break;
6859           case 0x08:
6860             goto op_semantics_43;
6861             break;
6862         }
6863       break;
6864     case 0xf3:
6865         GETBYTE ();
6866         switch (op[1] & 0x08)
6867         {
6868           case 0x00:
6869             goto op_semantics_42;
6870             break;
6871           case 0x08:
6872             goto op_semantics_43;
6873             break;
6874         }
6875       break;
6876     case 0xf4:
6877         GETBYTE ();
6878         switch (op[1] & 0x0c)
6879         {
6880           case 0x00:
6881           case 0x04:
6882             op_semantics_44:
6883               {
6884                 /** 1111 01sd rdst 0bit                 btst    #%2, %1%S1 */
6885 #line 889 "rx-decode.opc"
6886                 int sd AU = op[0] & 0x03;
6887 #line 889 "rx-decode.opc"
6888                 int rdst AU = (op[1] >> 4) & 0x0f;
6889 #line 889 "rx-decode.opc"
6890                 int bit AU = op[1] & 0x07;
6891                 if (trace)
6892                   {
6893                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6894                            "/** 1111 01sd rdst 0bit                     btst    #%2, %1%S1 */",
6895                            op[0], op[1]);
6896                     printf ("  sd = 0x%x,", sd);
6897                     printf ("  rdst = 0x%x,", rdst);
6898                     printf ("  bit = 0x%x\n", bit);
6899                   }
6900                 SYNTAX("btst    #%2, %1%S1");
6901 #line 889 "rx-decode.opc"
6902                 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F("--ZC");
6903
6904               }
6905             break;
6906           case 0x08:
6907             op_semantics_45:
6908               {
6909                 /** 1111 01ss rsrc 10sz         push%s  %1 */
6910 #line 357 "rx-decode.opc"
6911                 int ss AU = op[0] & 0x03;
6912 #line 357 "rx-decode.opc"
6913                 int rsrc AU = (op[1] >> 4) & 0x0f;
6914 #line 357 "rx-decode.opc"
6915                 int sz AU = op[1] & 0x03;
6916                 if (trace)
6917                   {
6918                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6919                            "/** 1111 01ss rsrc 10sz             push%s  %1 */",
6920                            op[0], op[1]);
6921                     printf ("  ss = 0x%x,", ss);
6922                     printf ("  rsrc = 0x%x,", rsrc);
6923                     printf ("  sz = 0x%x\n", sz);
6924                   }
6925                 SYNTAX("push%s  %1");
6926 #line 357 "rx-decode.opc"
6927                 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F("----");
6928
6929               /*----------------------------------------------------------------------*/
6930               /* XCHG                                                                   */
6931
6932               }
6933             break;
6934           default: UNSUPPORTED(); break;
6935         }
6936       break;
6937     case 0xf5:
6938         GETBYTE ();
6939         switch (op[1] & 0x0c)
6940         {
6941           case 0x00:
6942           case 0x04:
6943             goto op_semantics_44;
6944             break;
6945           case 0x08:
6946             goto op_semantics_45;
6947             break;
6948           default: UNSUPPORTED(); break;
6949         }
6950       break;
6951     case 0xf6:
6952         GETBYTE ();
6953         switch (op[1] & 0x0c)
6954         {
6955           case 0x00:
6956           case 0x04:
6957             goto op_semantics_44;
6958             break;
6959           case 0x08:
6960             goto op_semantics_45;
6961             break;
6962           default: UNSUPPORTED(); break;
6963         }
6964       break;
6965     case 0xf7:
6966         GETBYTE ();
6967         switch (op[1] & 0x0c)
6968         {
6969           case 0x00:
6970           case 0x04:
6971             goto op_semantics_44;
6972             break;
6973           case 0x08:
6974             goto op_semantics_45;
6975             break;
6976           default: UNSUPPORTED(); break;
6977         }
6978       break;
6979     case 0xf8:
6980         GETBYTE ();
6981         switch (op[1] & 0x00)
6982         {
6983           case 0x00:
6984             op_semantics_46:
6985               {
6986                 /** 1111 10sd rdst im sz        mov%s   #%1, %0 */
6987 #line 289 "rx-decode.opc"
6988                 int sd AU = op[0] & 0x03;
6989 #line 289 "rx-decode.opc"
6990                 int rdst AU = (op[1] >> 4) & 0x0f;
6991 #line 289 "rx-decode.opc"
6992                 int im AU = (op[1] >> 2) & 0x03;
6993 #line 289 "rx-decode.opc"
6994                 int sz AU = op[1] & 0x03;
6995                 if (trace)
6996                   {
6997                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6998                            "/** 1111 10sd rdst im sz    mov%s   #%1, %0 */",
6999                            op[0], op[1]);
7000                     printf ("  sd = 0x%x,", sd);
7001                     printf ("  rdst = 0x%x,", rdst);
7002                     printf ("  im = 0x%x,", im);
7003                     printf ("  sz = 0x%x\n", sz);
7004                   }
7005                 SYNTAX("mov%s   #%1, %0");
7006 #line 289 "rx-decode.opc"
7007                 ID(mov); sBWL (sz); DD(sd, rdst, sz); SC(IMMex(im)); F("----");
7008
7009               }
7010             break;
7011         }
7012       break;
7013     case 0xf9:
7014         GETBYTE ();
7015         switch (op[1] & 0x00)
7016         {
7017           case 0x00:
7018             goto op_semantics_46;
7019             break;
7020         }
7021       break;
7022     case 0xfa:
7023         GETBYTE ();
7024         switch (op[1] & 0x00)
7025         {
7026           case 0x00:
7027             goto op_semantics_46;
7028             break;
7029         }
7030       break;
7031     case 0xfb:
7032         GETBYTE ();
7033         switch (op[1] & 0x00)
7034         {
7035           case 0x00:
7036             goto op_semantics_46;
7037             break;
7038         }
7039       break;
7040     case 0xfc:
7041         GETBYTE ();
7042         switch (op[1] & 0xff)
7043         {
7044           case 0x03:
7045               GETBYTE ();
7046               switch (op[2] & 0x00)
7047               {
7048                 case 0x00:
7049                     {
7050                       /** 1111 1100 0000 0011 rsrc rdst sbb     %1, %0 */
7051 #line 531 "rx-decode.opc"
7052                       int rsrc AU = (op[2] >> 4) & 0x0f;
7053 #line 531 "rx-decode.opc"
7054                       int rdst AU = op[2] & 0x0f;
7055                       if (trace)
7056                         {
7057                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7058                                  "/** 1111 1100 0000 0011 rsrc rdst     sbb     %1, %0 */",
7059                                  op[0], op[1], op[2]);
7060                           printf ("  rsrc = 0x%x,", rsrc);
7061                           printf ("  rdst = 0x%x\n", rdst);
7062                         }
7063                       SYNTAX("sbb       %1, %0");
7064 #line 531 "rx-decode.opc"
7065                       ID(sbb); SR (rsrc); DR(rdst); F("OSZC");
7066
7067                       /* FIXME: only supports .L */
7068                     }
7069                   break;
7070               }
7071             break;
7072           case 0x07:
7073               GETBYTE ();
7074               switch (op[2] & 0x00)
7075               {
7076                 case 0x00:
7077                     {
7078                       /** 1111 1100 0000 0111 rsrc rdst neg     %2, %0 */
7079 #line 462 "rx-decode.opc"
7080                       int rsrc AU = (op[2] >> 4) & 0x0f;
7081 #line 462 "rx-decode.opc"
7082                       int rdst AU = op[2] & 0x0f;
7083                       if (trace)
7084                         {
7085                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7086                                  "/** 1111 1100 0000 0111 rsrc rdst     neg     %2, %0 */",
7087                                  op[0], op[1], op[2]);
7088                           printf ("  rsrc = 0x%x,", rsrc);
7089                           printf ("  rdst = 0x%x\n", rdst);
7090                         }
7091                       SYNTAX("neg       %2, %0");
7092 #line 462 "rx-decode.opc"
7093                       ID(sub); DR(rdst); SC(0); S2R(rsrc); F("OSZC");
7094
7095                     /*----------------------------------------------------------------------*/
7096                     /* ADC                                                                      */
7097
7098                     }
7099                   break;
7100               }
7101             break;
7102           case 0x0b:
7103               GETBYTE ();
7104               switch (op[2] & 0x00)
7105               {
7106                 case 0x00:
7107                     {
7108                       /** 1111 1100 0000 1011 rsrc rdst adc     %1, %0 */
7109 #line 471 "rx-decode.opc"
7110                       int rsrc AU = (op[2] >> 4) & 0x0f;
7111 #line 471 "rx-decode.opc"
7112                       int rdst AU = op[2] & 0x0f;
7113                       if (trace)
7114                         {
7115                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7116                                  "/** 1111 1100 0000 1011 rsrc rdst     adc     %1, %0 */",
7117                                  op[0], op[1], op[2]);
7118                           printf ("  rsrc = 0x%x,", rsrc);
7119                           printf ("  rdst = 0x%x\n", rdst);
7120                         }
7121                       SYNTAX("adc       %1, %0");
7122 #line 471 "rx-decode.opc"
7123                       ID(adc); SR(rsrc); DR(rdst); F("OSZC");
7124
7125                     }
7126                   break;
7127               }
7128             break;
7129           case 0x0f:
7130               GETBYTE ();
7131               switch (op[2] & 0x00)
7132               {
7133                 case 0x00:
7134                     {
7135                       /** 1111 1100 0000 1111 rsrc rdst abs     %1, %0 */
7136 #line 544 "rx-decode.opc"
7137                       int rsrc AU = (op[2] >> 4) & 0x0f;
7138 #line 544 "rx-decode.opc"
7139                       int rdst AU = op[2] & 0x0f;
7140                       if (trace)
7141                         {
7142                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7143                                  "/** 1111 1100 0000 1111 rsrc rdst     abs     %1, %0 */",
7144                                  op[0], op[1], op[2]);
7145                           printf ("  rsrc = 0x%x,", rsrc);
7146                           printf ("  rdst = 0x%x\n", rdst);
7147                         }
7148                       SYNTAX("abs       %1, %0");
7149 #line 544 "rx-decode.opc"
7150                       ID(abs); DR(rdst); SR(rsrc); F("OSZ-");
7151
7152                     /*----------------------------------------------------------------------*/
7153                     /* MAX                                                                      */
7154
7155                     }
7156                   break;
7157               }
7158             break;
7159           case 0x10:
7160               GETBYTE ();
7161               switch (op[2] & 0x00)
7162               {
7163                 case 0x00:
7164                   op_semantics_47:
7165                     {
7166                       /** 1111 1100 0001 00ss rsrc rdst max     %1%S1, %0 */
7167 #line 553 "rx-decode.opc"
7168                       int ss AU = op[1] & 0x03;
7169 #line 553 "rx-decode.opc"
7170                       int rsrc AU = (op[2] >> 4) & 0x0f;
7171 #line 553 "rx-decode.opc"
7172                       int rdst AU = op[2] & 0x0f;
7173                       if (trace)
7174                         {
7175                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7176                                  "/** 1111 1100 0001 00ss rsrc rdst     max     %1%S1, %0 */",
7177                                  op[0], op[1], op[2]);
7178                           printf ("  ss = 0x%x,", ss);
7179                           printf ("  rsrc = 0x%x,", rsrc);
7180                           printf ("  rdst = 0x%x\n", rdst);
7181                         }
7182                       SYNTAX("max       %1%S1, %0");
7183 #line 553 "rx-decode.opc"
7184                       ID(max); SP(ss, rsrc); DR(rdst);
7185
7186                     }
7187                   break;
7188               }
7189             break;
7190           case 0x11:
7191               GETBYTE ();
7192               switch (op[2] & 0x00)
7193               {
7194                 case 0x00:
7195                   goto op_semantics_47;
7196                   break;
7197               }
7198             break;
7199           case 0x12:
7200               GETBYTE ();
7201               switch (op[2] & 0x00)
7202               {
7203                 case 0x00:
7204                   goto op_semantics_47;
7205                   break;
7206               }
7207             break;
7208           case 0x13:
7209               GETBYTE ();
7210               switch (op[2] & 0x00)
7211               {
7212                 case 0x00:
7213                   goto op_semantics_47;
7214                   break;
7215               }
7216             break;
7217           case 0x14:
7218               GETBYTE ();
7219               switch (op[2] & 0x00)
7220               {
7221                 case 0x00:
7222                   op_semantics_48:
7223                     {
7224                       /** 1111 1100 0001 01ss rsrc rdst min     %1%S1, %0 */
7225 #line 565 "rx-decode.opc"
7226                       int ss AU = op[1] & 0x03;
7227 #line 565 "rx-decode.opc"
7228                       int rsrc AU = (op[2] >> 4) & 0x0f;
7229 #line 565 "rx-decode.opc"
7230                       int rdst AU = op[2] & 0x0f;
7231                       if (trace)
7232                         {
7233                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7234                                  "/** 1111 1100 0001 01ss rsrc rdst     min     %1%S1, %0 */",
7235                                  op[0], op[1], op[2]);
7236                           printf ("  ss = 0x%x,", ss);
7237                           printf ("  rsrc = 0x%x,", rsrc);
7238                           printf ("  rdst = 0x%x\n", rdst);
7239                         }
7240                       SYNTAX("min       %1%S1, %0");
7241 #line 565 "rx-decode.opc"
7242                       ID(min); SP(ss, rsrc); DR(rdst);
7243
7244                     }
7245                   break;
7246               }
7247             break;
7248           case 0x15:
7249               GETBYTE ();
7250               switch (op[2] & 0x00)
7251               {
7252                 case 0x00:
7253                   goto op_semantics_48;
7254                   break;
7255               }
7256             break;
7257           case 0x16:
7258               GETBYTE ();
7259               switch (op[2] & 0x00)
7260               {
7261                 case 0x00:
7262                   goto op_semantics_48;
7263                   break;
7264               }
7265             break;
7266           case 0x17:
7267               GETBYTE ();
7268               switch (op[2] & 0x00)
7269               {
7270                 case 0x00:
7271                   goto op_semantics_48;
7272                   break;
7273               }
7274             break;
7275           case 0x18:
7276               GETBYTE ();
7277               switch (op[2] & 0x00)
7278               {
7279                 case 0x00:
7280                   op_semantics_49:
7281                     {
7282                       /** 1111 1100 0001 10ss rsrc rdst emul    %1%S1, %0 */
7283 #line 595 "rx-decode.opc"
7284                       int ss AU = op[1] & 0x03;
7285 #line 595 "rx-decode.opc"
7286                       int rsrc AU = (op[2] >> 4) & 0x0f;
7287 #line 595 "rx-decode.opc"
7288                       int rdst AU = op[2] & 0x0f;
7289                       if (trace)
7290                         {
7291                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7292                                  "/** 1111 1100 0001 10ss rsrc rdst     emul    %1%S1, %0 */",
7293                                  op[0], op[1], op[2]);
7294                           printf ("  ss = 0x%x,", ss);
7295                           printf ("  rsrc = 0x%x,", rsrc);
7296                           printf ("  rdst = 0x%x\n", rdst);
7297                         }
7298                       SYNTAX("emul      %1%S1, %0");
7299 #line 595 "rx-decode.opc"
7300                       ID(emul); SP(ss, rsrc); DR(rdst);
7301
7302                     }
7303                   break;
7304               }
7305             break;
7306           case 0x19:
7307               GETBYTE ();
7308               switch (op[2] & 0x00)
7309               {
7310                 case 0x00:
7311                   goto op_semantics_49;
7312                   break;
7313               }
7314             break;
7315           case 0x1a:
7316               GETBYTE ();
7317               switch (op[2] & 0x00)
7318               {
7319                 case 0x00:
7320                   goto op_semantics_49;
7321                   break;
7322               }
7323             break;
7324           case 0x1b:
7325               GETBYTE ();
7326               switch (op[2] & 0x00)
7327               {
7328                 case 0x00:
7329                   goto op_semantics_49;
7330                   break;
7331               }
7332             break;
7333           case 0x1c:
7334               GETBYTE ();
7335               switch (op[2] & 0x00)
7336               {
7337                 case 0x00:
7338                   op_semantics_50:
7339                     {
7340                       /** 1111 1100 0001 11ss rsrc rdst emulu   %1%S1, %0 */
7341 #line 607 "rx-decode.opc"
7342                       int ss AU = op[1] & 0x03;
7343 #line 607 "rx-decode.opc"
7344                       int rsrc AU = (op[2] >> 4) & 0x0f;
7345 #line 607 "rx-decode.opc"
7346                       int rdst AU = op[2] & 0x0f;
7347                       if (trace)
7348                         {
7349                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7350                                  "/** 1111 1100 0001 11ss rsrc rdst     emulu   %1%S1, %0 */",
7351                                  op[0], op[1], op[2]);
7352                           printf ("  ss = 0x%x,", ss);
7353                           printf ("  rsrc = 0x%x,", rsrc);
7354                           printf ("  rdst = 0x%x\n", rdst);
7355                         }
7356                       SYNTAX("emulu     %1%S1, %0");
7357 #line 607 "rx-decode.opc"
7358                       ID(emulu); SP(ss, rsrc); DR(rdst);
7359
7360                     }
7361                   break;
7362               }
7363             break;
7364           case 0x1d:
7365               GETBYTE ();
7366               switch (op[2] & 0x00)
7367               {
7368                 case 0x00:
7369                   goto op_semantics_50;
7370                   break;
7371               }
7372             break;
7373           case 0x1e:
7374               GETBYTE ();
7375               switch (op[2] & 0x00)
7376               {
7377                 case 0x00:
7378                   goto op_semantics_50;
7379                   break;
7380               }
7381             break;
7382           case 0x1f:
7383               GETBYTE ();
7384               switch (op[2] & 0x00)
7385               {
7386                 case 0x00:
7387                   goto op_semantics_50;
7388                   break;
7389               }
7390             break;
7391           case 0x20:
7392               GETBYTE ();
7393               switch (op[2] & 0x00)
7394               {
7395                 case 0x00:
7396                   op_semantics_51:
7397                     {
7398                       /** 1111 1100 0010 00ss rsrc rdst div     %1%S1, %0 */
7399 #line 619 "rx-decode.opc"
7400                       int ss AU = op[1] & 0x03;
7401 #line 619 "rx-decode.opc"
7402                       int rsrc AU = (op[2] >> 4) & 0x0f;
7403 #line 619 "rx-decode.opc"
7404                       int rdst AU = op[2] & 0x0f;
7405                       if (trace)
7406                         {
7407                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7408                                  "/** 1111 1100 0010 00ss rsrc rdst     div     %1%S1, %0 */",
7409                                  op[0], op[1], op[2]);
7410                           printf ("  ss = 0x%x,", ss);
7411                           printf ("  rsrc = 0x%x,", rsrc);
7412                           printf ("  rdst = 0x%x\n", rdst);
7413                         }
7414                       SYNTAX("div       %1%S1, %0");
7415 #line 619 "rx-decode.opc"
7416                       ID(div); SP(ss, rsrc); DR(rdst); F("O---");
7417
7418                     }
7419                   break;
7420               }
7421             break;
7422           case 0x21:
7423               GETBYTE ();
7424               switch (op[2] & 0x00)
7425               {
7426                 case 0x00:
7427                   goto op_semantics_51;
7428                   break;
7429               }
7430             break;
7431           case 0x22:
7432               GETBYTE ();
7433               switch (op[2] & 0x00)
7434               {
7435                 case 0x00:
7436                   goto op_semantics_51;
7437                   break;
7438               }
7439             break;
7440           case 0x23:
7441               GETBYTE ();
7442               switch (op[2] & 0x00)
7443               {
7444                 case 0x00:
7445                   goto op_semantics_51;
7446                   break;
7447               }
7448             break;
7449           case 0x24:
7450               GETBYTE ();
7451               switch (op[2] & 0x00)
7452               {
7453                 case 0x00:
7454                   op_semantics_52:
7455                     {
7456                       /** 1111 1100 0010 01ss rsrc rdst divu    %1%S1, %0 */
7457 #line 631 "rx-decode.opc"
7458                       int ss AU = op[1] & 0x03;
7459 #line 631 "rx-decode.opc"
7460                       int rsrc AU = (op[2] >> 4) & 0x0f;
7461 #line 631 "rx-decode.opc"
7462                       int rdst AU = op[2] & 0x0f;
7463                       if (trace)
7464                         {
7465                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7466                                  "/** 1111 1100 0010 01ss rsrc rdst     divu    %1%S1, %0 */",
7467                                  op[0], op[1], op[2]);
7468                           printf ("  ss = 0x%x,", ss);
7469                           printf ("  rsrc = 0x%x,", rsrc);
7470                           printf ("  rdst = 0x%x\n", rdst);
7471                         }
7472                       SYNTAX("divu      %1%S1, %0");
7473 #line 631 "rx-decode.opc"
7474                       ID(divu); SP(ss, rsrc); DR(rdst); F("O---");
7475
7476                     }
7477                   break;
7478               }
7479             break;
7480           case 0x25:
7481               GETBYTE ();
7482               switch (op[2] & 0x00)
7483               {
7484                 case 0x00:
7485                   goto op_semantics_52;
7486                   break;
7487               }
7488             break;
7489           case 0x26:
7490               GETBYTE ();
7491               switch (op[2] & 0x00)
7492               {
7493                 case 0x00:
7494                   goto op_semantics_52;
7495                   break;
7496               }
7497             break;
7498           case 0x27:
7499               GETBYTE ();
7500               switch (op[2] & 0x00)
7501               {
7502                 case 0x00:
7503                   goto op_semantics_52;
7504                   break;
7505               }
7506             break;
7507           case 0x30:
7508               GETBYTE ();
7509               switch (op[2] & 0x00)
7510               {
7511                 case 0x00:
7512                   op_semantics_53:
7513                     {
7514                       /** 1111 1100 0011 00ss rsrc rdst tst     %1%S1, %2 */
7515 #line 450 "rx-decode.opc"
7516                       int ss AU = op[1] & 0x03;
7517 #line 450 "rx-decode.opc"
7518                       int rsrc AU = (op[2] >> 4) & 0x0f;
7519 #line 450 "rx-decode.opc"
7520                       int rdst AU = op[2] & 0x0f;
7521                       if (trace)
7522                         {
7523                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7524                                  "/** 1111 1100 0011 00ss rsrc rdst     tst     %1%S1, %2 */",
7525                                  op[0], op[1], op[2]);
7526                           printf ("  ss = 0x%x,", ss);
7527                           printf ("  rsrc = 0x%x,", rsrc);
7528                           printf ("  rdst = 0x%x\n", rdst);
7529                         }
7530                       SYNTAX("tst       %1%S1, %2");
7531 #line 450 "rx-decode.opc"
7532                       ID(and); SP(ss, rsrc); S2R(rdst); F("-SZ-");
7533
7534                     }
7535                   break;
7536               }
7537             break;
7538           case 0x31:
7539               GETBYTE ();
7540               switch (op[2] & 0x00)
7541               {
7542                 case 0x00:
7543                   goto op_semantics_53;
7544                   break;
7545               }
7546             break;
7547           case 0x32:
7548               GETBYTE ();
7549               switch (op[2] & 0x00)
7550               {
7551                 case 0x00:
7552                   goto op_semantics_53;
7553                   break;
7554               }
7555             break;
7556           case 0x33:
7557               GETBYTE ();
7558               switch (op[2] & 0x00)
7559               {
7560                 case 0x00:
7561                   goto op_semantics_53;
7562                   break;
7563               }
7564             break;
7565           case 0x34:
7566               GETBYTE ();
7567               switch (op[2] & 0x00)
7568               {
7569                 case 0x00:
7570                   op_semantics_54:
7571                     {
7572                       /** 1111 1100 0011 01ss rsrc rdst xor     %1%S1, %0 */
7573 #line 429 "rx-decode.opc"
7574                       int ss AU = op[1] & 0x03;
7575 #line 429 "rx-decode.opc"
7576                       int rsrc AU = (op[2] >> 4) & 0x0f;
7577 #line 429 "rx-decode.opc"
7578                       int rdst AU = op[2] & 0x0f;
7579                       if (trace)
7580                         {
7581                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7582                                  "/** 1111 1100 0011 01ss rsrc rdst     xor     %1%S1, %0 */",
7583                                  op[0], op[1], op[2]);
7584                           printf ("  ss = 0x%x,", ss);
7585                           printf ("  rsrc = 0x%x,", rsrc);
7586                           printf ("  rdst = 0x%x\n", rdst);
7587                         }
7588                       SYNTAX("xor       %1%S1, %0");
7589 #line 429 "rx-decode.opc"
7590                       ID(xor); SP(ss, rsrc); DR(rdst); F("-SZ-");
7591
7592                     }
7593                   break;
7594               }
7595             break;
7596           case 0x35:
7597               GETBYTE ();
7598               switch (op[2] & 0x00)
7599               {
7600                 case 0x00:
7601                   goto op_semantics_54;
7602                   break;
7603               }
7604             break;
7605           case 0x36:
7606               GETBYTE ();
7607               switch (op[2] & 0x00)
7608               {
7609                 case 0x00:
7610                   goto op_semantics_54;
7611                   break;
7612               }
7613             break;
7614           case 0x37:
7615               GETBYTE ();
7616               switch (op[2] & 0x00)
7617               {
7618                 case 0x00:
7619                   goto op_semantics_54;
7620                   break;
7621               }
7622             break;
7623           case 0x3b:
7624               GETBYTE ();
7625               switch (op[2] & 0x00)
7626               {
7627                 case 0x00:
7628                     {
7629                       /** 1111 1100 0011 1011 rsrc rdst not     %1, %0 */
7630 #line 441 "rx-decode.opc"
7631                       int rsrc AU = (op[2] >> 4) & 0x0f;
7632 #line 441 "rx-decode.opc"
7633                       int rdst AU = op[2] & 0x0f;
7634                       if (trace)
7635                         {
7636                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7637                                  "/** 1111 1100 0011 1011 rsrc rdst     not     %1, %0 */",
7638                                  op[0], op[1], op[2]);
7639                           printf ("  rsrc = 0x%x,", rsrc);
7640                           printf ("  rdst = 0x%x\n", rdst);
7641                         }
7642                       SYNTAX("not       %1, %0");
7643 #line 441 "rx-decode.opc"
7644                       ID(xor); DR(rdst); SR(rsrc); S2C(~0); F("-SZ-");
7645
7646                     /*----------------------------------------------------------------------*/
7647                     /* TST                                                                      */
7648
7649                     }
7650                   break;
7651               }
7652             break;
7653           case 0x40:
7654               GETBYTE ();
7655               switch (op[2] & 0x00)
7656               {
7657                 case 0x00:
7658                   op_semantics_55:
7659                     {
7660                       /** 1111 1100 0100 00ss rsrc rdst xchg    %1%S1, %0 */
7661 #line 363 "rx-decode.opc"
7662                       int ss AU = op[1] & 0x03;
7663 #line 363 "rx-decode.opc"
7664                       int rsrc AU = (op[2] >> 4) & 0x0f;
7665 #line 363 "rx-decode.opc"
7666                       int rdst AU = op[2] & 0x0f;
7667                       if (trace)
7668                         {
7669                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7670                                  "/** 1111 1100 0100 00ss rsrc rdst     xchg    %1%S1, %0 */",
7671                                  op[0], op[1], op[2]);
7672                           printf ("  ss = 0x%x,", ss);
7673                           printf ("  rsrc = 0x%x,", rsrc);
7674                           printf ("  rdst = 0x%x\n", rdst);
7675                         }
7676                       SYNTAX("xchg      %1%S1, %0");
7677 #line 363 "rx-decode.opc"
7678                       ID(xchg); DR(rdst); SP(ss, rsrc);
7679
7680                     }
7681                   break;
7682               }
7683             break;
7684           case 0x41:
7685               GETBYTE ();
7686               switch (op[2] & 0x00)
7687               {
7688                 case 0x00:
7689                   goto op_semantics_55;
7690                   break;
7691               }
7692             break;
7693           case 0x42:
7694               GETBYTE ();
7695               switch (op[2] & 0x00)
7696               {
7697                 case 0x00:
7698                   goto op_semantics_55;
7699                   break;
7700               }
7701             break;
7702           case 0x43:
7703               GETBYTE ();
7704               switch (op[2] & 0x00)
7705               {
7706                 case 0x00:
7707                   goto op_semantics_55;
7708                   break;
7709               }
7710             break;
7711           case 0x44:
7712               GETBYTE ();
7713               switch (op[2] & 0x00)
7714               {
7715                 case 0x00:
7716                   op_semantics_56:
7717                     {
7718                       /** 1111 1100 0100 01sd rsrc rdst itof    %1%S1, %0 */
7719 #line 860 "rx-decode.opc"
7720                       int sd AU = op[1] & 0x03;
7721 #line 860 "rx-decode.opc"
7722                       int rsrc AU = (op[2] >> 4) & 0x0f;
7723 #line 860 "rx-decode.opc"
7724                       int rdst AU = op[2] & 0x0f;
7725                       if (trace)
7726                         {
7727                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7728                                  "/** 1111 1100 0100 01sd rsrc rdst     itof    %1%S1, %0 */",
7729                                  op[0], op[1], op[2]);
7730                           printf ("  sd = 0x%x,", sd);
7731                           printf ("  rsrc = 0x%x,", rsrc);
7732                           printf ("  rdst = 0x%x\n", rdst);
7733                         }
7734                       SYNTAX("itof      %1%S1, %0");
7735 #line 860 "rx-decode.opc"
7736                       ID(itof); DR (rdst); SP(sd, rsrc); F("-SZ-");
7737
7738                     }
7739                   break;
7740               }
7741             break;
7742           case 0x45:
7743               GETBYTE ();
7744               switch (op[2] & 0x00)
7745               {
7746                 case 0x00:
7747                   goto op_semantics_56;
7748                   break;
7749               }
7750             break;
7751           case 0x46:
7752               GETBYTE ();
7753               switch (op[2] & 0x00)
7754               {
7755                 case 0x00:
7756                   goto op_semantics_56;
7757                   break;
7758               }
7759             break;
7760           case 0x47:
7761               GETBYTE ();
7762               switch (op[2] & 0x00)
7763               {
7764                 case 0x00:
7765                   goto op_semantics_56;
7766                   break;
7767               }
7768             break;
7769           case 0x60:
7770               GETBYTE ();
7771               switch (op[2] & 0x00)
7772               {
7773                 case 0x00:
7774                   op_semantics_57:
7775                     {
7776                       /** 1111 1100 0110 00sd rdst rsrc bset    %1, %0%S0 */
7777 #line 872 "rx-decode.opc"
7778                       int sd AU = op[1] & 0x03;
7779 #line 872 "rx-decode.opc"
7780                       int rdst AU = (op[2] >> 4) & 0x0f;
7781 #line 872 "rx-decode.opc"
7782                       int rsrc AU = op[2] & 0x0f;
7783                       if (trace)
7784                         {
7785                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7786                                  "/** 1111 1100 0110 00sd rdst rsrc     bset    %1, %0%S0 */",
7787                                  op[0], op[1], op[2]);
7788                           printf ("  sd = 0x%x,", sd);
7789                           printf ("  rdst = 0x%x,", rdst);
7790                           printf ("  rsrc = 0x%x\n", rsrc);
7791                         }
7792                       SYNTAX("bset      %1, %0%S0");
7793 #line 872 "rx-decode.opc"
7794                       ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F("----");
7795
7796                     }
7797                   break;
7798               }
7799             break;
7800           case 0x61:
7801               GETBYTE ();
7802               switch (op[2] & 0x00)
7803               {
7804                 case 0x00:
7805                   goto op_semantics_57;
7806                   break;
7807               }
7808             break;
7809           case 0x62:
7810               GETBYTE ();
7811               switch (op[2] & 0x00)
7812               {
7813                 case 0x00:
7814                   goto op_semantics_57;
7815                   break;
7816               }
7817             break;
7818           case 0x63:
7819               GETBYTE ();
7820               switch (op[2] & 0x00)
7821               {
7822                 case 0x00:
7823                   goto op_semantics_57;
7824                   break;
7825               }
7826             break;
7827           case 0x64:
7828               GETBYTE ();
7829               switch (op[2] & 0x00)
7830               {
7831                 case 0x00:
7832                   op_semantics_58:
7833                     {
7834                       /** 1111 1100 0110 01sd rdst rsrc bclr    %1, %0%S0 */
7835 #line 882 "rx-decode.opc"
7836                       int sd AU = op[1] & 0x03;
7837 #line 882 "rx-decode.opc"
7838                       int rdst AU = (op[2] >> 4) & 0x0f;
7839 #line 882 "rx-decode.opc"
7840                       int rsrc AU = op[2] & 0x0f;
7841                       if (trace)
7842                         {
7843                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7844                                  "/** 1111 1100 0110 01sd rdst rsrc     bclr    %1, %0%S0 */",
7845                                  op[0], op[1], op[2]);
7846                           printf ("  sd = 0x%x,", sd);
7847                           printf ("  rdst = 0x%x,", rdst);
7848                           printf ("  rsrc = 0x%x\n", rsrc);
7849                         }
7850                       SYNTAX("bclr      %1, %0%S0");
7851 #line 882 "rx-decode.opc"
7852                       ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F("----");
7853
7854                     }
7855                   break;
7856               }
7857             break;
7858           case 0x65:
7859               GETBYTE ();
7860               switch (op[2] & 0x00)
7861               {
7862                 case 0x00:
7863                   goto op_semantics_58;
7864                   break;
7865               }
7866             break;
7867           case 0x66:
7868               GETBYTE ();
7869               switch (op[2] & 0x00)
7870               {
7871                 case 0x00:
7872                   goto op_semantics_58;
7873                   break;
7874               }
7875             break;
7876           case 0x67:
7877               GETBYTE ();
7878               switch (op[2] & 0x00)
7879               {
7880                 case 0x00:
7881                   goto op_semantics_58;
7882                   break;
7883               }
7884             break;
7885           case 0x68:
7886               GETBYTE ();
7887               switch (op[2] & 0x00)
7888               {
7889                 case 0x00:
7890                   op_semantics_59:
7891                     {
7892                       /** 1111 1100 0110 10sd rdst rsrc btst    %2, %1%S1 */
7893 #line 892 "rx-decode.opc"
7894                       int sd AU = op[1] & 0x03;
7895 #line 892 "rx-decode.opc"
7896                       int rdst AU = (op[2] >> 4) & 0x0f;
7897 #line 892 "rx-decode.opc"
7898                       int rsrc AU = op[2] & 0x0f;
7899                       if (trace)
7900                         {
7901                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7902                                  "/** 1111 1100 0110 10sd rdst rsrc     btst    %2, %1%S1 */",
7903                                  op[0], op[1], op[2]);
7904                           printf ("  sd = 0x%x,", sd);
7905                           printf ("  rdst = 0x%x,", rdst);
7906                           printf ("  rsrc = 0x%x\n", rsrc);
7907                         }
7908                       SYNTAX("btst      %2, %1%S1");
7909 #line 892 "rx-decode.opc"
7910                       ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F("--ZC");
7911
7912                     }
7913                   break;
7914               }
7915             break;
7916           case 0x69:
7917               GETBYTE ();
7918               switch (op[2] & 0x00)
7919               {
7920                 case 0x00:
7921                   goto op_semantics_59;
7922                   break;
7923               }
7924             break;
7925           case 0x6a:
7926               GETBYTE ();
7927               switch (op[2] & 0x00)
7928               {
7929                 case 0x00:
7930                   goto op_semantics_59;
7931                   break;
7932               }
7933             break;
7934           case 0x6b:
7935               GETBYTE ();
7936               switch (op[2] & 0x00)
7937               {
7938                 case 0x00:
7939                   goto op_semantics_59;
7940                   break;
7941               }
7942             break;
7943           case 0x6c:
7944               GETBYTE ();
7945               switch (op[2] & 0x00)
7946               {
7947                 case 0x00:
7948                   op_semantics_60:
7949                     {
7950                       /** 1111 1100 0110 11sd rdst rsrc bnot    %1, %0%S0 */
7951 #line 902 "rx-decode.opc"
7952                       int sd AU = op[1] & 0x03;
7953 #line 902 "rx-decode.opc"
7954                       int rdst AU = (op[2] >> 4) & 0x0f;
7955 #line 902 "rx-decode.opc"
7956                       int rsrc AU = op[2] & 0x0f;
7957                       if (trace)
7958                         {
7959                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7960                                  "/** 1111 1100 0110 11sd rdst rsrc     bnot    %1, %0%S0 */",
7961                                  op[0], op[1], op[2]);
7962                           printf ("  sd = 0x%x,", sd);
7963                           printf ("  rdst = 0x%x,", rdst);
7964                           printf ("  rsrc = 0x%x\n", rsrc);
7965                         }
7966                       SYNTAX("bnot      %1, %0%S0");
7967 #line 902 "rx-decode.opc"
7968                       ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
7969
7970                     }
7971                   break;
7972               }
7973             break;
7974           case 0x6d:
7975               GETBYTE ();
7976               switch (op[2] & 0x00)
7977               {
7978                 case 0x00:
7979                   goto op_semantics_60;
7980                   break;
7981               }
7982             break;
7983           case 0x6e:
7984               GETBYTE ();
7985               switch (op[2] & 0x00)
7986               {
7987                 case 0x00:
7988                   goto op_semantics_60;
7989                   break;
7990               }
7991             break;
7992           case 0x6f:
7993               GETBYTE ();
7994               switch (op[2] & 0x00)
7995               {
7996                 case 0x00:
7997                   goto op_semantics_60;
7998                   break;
7999               }
8000             break;
8001           case 0x80:
8002               GETBYTE ();
8003               switch (op[2] & 0x00)
8004               {
8005                 case 0x00:
8006                   op_semantics_61:
8007                     {
8008                       /** 1111 1100 1000 00sd rsrc rdst fsub    %1%S1, %0 */
8009 #line 839 "rx-decode.opc"
8010                       int sd AU = op[1] & 0x03;
8011 #line 839 "rx-decode.opc"
8012                       int rsrc AU = (op[2] >> 4) & 0x0f;
8013 #line 839 "rx-decode.opc"
8014                       int rdst AU = op[2] & 0x0f;
8015                       if (trace)
8016                         {
8017                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8018                                  "/** 1111 1100 1000 00sd rsrc rdst     fsub    %1%S1, %0 */",
8019                                  op[0], op[1], op[2]);
8020                           printf ("  sd = 0x%x,", sd);
8021                           printf ("  rsrc = 0x%x,", rsrc);
8022                           printf ("  rdst = 0x%x\n", rdst);
8023                         }
8024                       SYNTAX("fsub      %1%S1, %0");
8025 #line 839 "rx-decode.opc"
8026                       ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8027
8028                     }
8029                   break;
8030               }
8031             break;
8032           case 0x81:
8033               GETBYTE ();
8034               switch (op[2] & 0x00)
8035               {
8036                 case 0x00:
8037                   goto op_semantics_61;
8038                   break;
8039               }
8040             break;
8041           case 0x82:
8042               GETBYTE ();
8043               switch (op[2] & 0x00)
8044               {
8045                 case 0x00:
8046                   goto op_semantics_61;
8047                   break;
8048               }
8049             break;
8050           case 0x83:
8051               GETBYTE ();
8052               switch (op[2] & 0x00)
8053               {
8054                 case 0x00:
8055                   goto op_semantics_61;
8056                   break;
8057               }
8058             break;
8059           case 0x84:
8060               GETBYTE ();
8061               switch (op[2] & 0x00)
8062               {
8063                 case 0x00:
8064                   op_semantics_62:
8065                     {
8066                       /** 1111 1100 1000 01sd rsrc rdst fcmp    %1%S1, %0 */
8067 #line 833 "rx-decode.opc"
8068                       int sd AU = op[1] & 0x03;
8069 #line 833 "rx-decode.opc"
8070                       int rsrc AU = (op[2] >> 4) & 0x0f;
8071 #line 833 "rx-decode.opc"
8072                       int rdst AU = op[2] & 0x0f;
8073                       if (trace)
8074                         {
8075                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8076                                  "/** 1111 1100 1000 01sd rsrc rdst     fcmp    %1%S1, %0 */",
8077                                  op[0], op[1], op[2]);
8078                           printf ("  sd = 0x%x,", sd);
8079                           printf ("  rsrc = 0x%x,", rsrc);
8080                           printf ("  rdst = 0x%x\n", rdst);
8081                         }
8082                       SYNTAX("fcmp      %1%S1, %0");
8083 #line 833 "rx-decode.opc"
8084                       ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F("OSZ-");
8085
8086                     }
8087                   break;
8088               }
8089             break;
8090           case 0x85:
8091               GETBYTE ();
8092               switch (op[2] & 0x00)
8093               {
8094                 case 0x00:
8095                   goto op_semantics_62;
8096                   break;
8097               }
8098             break;
8099           case 0x86:
8100               GETBYTE ();
8101               switch (op[2] & 0x00)
8102               {
8103                 case 0x00:
8104                   goto op_semantics_62;
8105                   break;
8106               }
8107             break;
8108           case 0x87:
8109               GETBYTE ();
8110               switch (op[2] & 0x00)
8111               {
8112                 case 0x00:
8113                   goto op_semantics_62;
8114                   break;
8115               }
8116             break;
8117           case 0x88:
8118               GETBYTE ();
8119               switch (op[2] & 0x00)
8120               {
8121                 case 0x00:
8122                   op_semantics_63:
8123                     {
8124                       /** 1111 1100 1000 10sd rsrc rdst fadd    %1%S1, %0 */
8125 #line 827 "rx-decode.opc"
8126                       int sd AU = op[1] & 0x03;
8127 #line 827 "rx-decode.opc"
8128                       int rsrc AU = (op[2] >> 4) & 0x0f;
8129 #line 827 "rx-decode.opc"
8130                       int rdst AU = op[2] & 0x0f;
8131                       if (trace)
8132                         {
8133                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8134                                  "/** 1111 1100 1000 10sd rsrc rdst     fadd    %1%S1, %0 */",
8135                                  op[0], op[1], op[2]);
8136                           printf ("  sd = 0x%x,", sd);
8137                           printf ("  rsrc = 0x%x,", rsrc);
8138                           printf ("  rdst = 0x%x\n", rdst);
8139                         }
8140                       SYNTAX("fadd      %1%S1, %0");
8141 #line 827 "rx-decode.opc"
8142                       ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8143
8144                     }
8145                   break;
8146               }
8147             break;
8148           case 0x89:
8149               GETBYTE ();
8150               switch (op[2] & 0x00)
8151               {
8152                 case 0x00:
8153                   goto op_semantics_63;
8154                   break;
8155               }
8156             break;
8157           case 0x8a:
8158               GETBYTE ();
8159               switch (op[2] & 0x00)
8160               {
8161                 case 0x00:
8162                   goto op_semantics_63;
8163                   break;
8164               }
8165             break;
8166           case 0x8b:
8167               GETBYTE ();
8168               switch (op[2] & 0x00)
8169               {
8170                 case 0x00:
8171                   goto op_semantics_63;
8172                   break;
8173               }
8174             break;
8175           case 0x8c:
8176               GETBYTE ();
8177               switch (op[2] & 0x00)
8178               {
8179                 case 0x00:
8180                   op_semantics_64:
8181                     {
8182                       /** 1111 1100 1000 11sd rsrc rdst fmul    %1%S1, %0 */
8183 #line 848 "rx-decode.opc"
8184                       int sd AU = op[1] & 0x03;
8185 #line 848 "rx-decode.opc"
8186                       int rsrc AU = (op[2] >> 4) & 0x0f;
8187 #line 848 "rx-decode.opc"
8188                       int rdst AU = op[2] & 0x0f;
8189                       if (trace)
8190                         {
8191                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8192                                  "/** 1111 1100 1000 11sd rsrc rdst     fmul    %1%S1, %0 */",
8193                                  op[0], op[1], op[2]);
8194                           printf ("  sd = 0x%x,", sd);
8195                           printf ("  rsrc = 0x%x,", rsrc);
8196                           printf ("  rdst = 0x%x\n", rdst);
8197                         }
8198                       SYNTAX("fmul      %1%S1, %0");
8199 #line 848 "rx-decode.opc"
8200                       ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8201
8202                     }
8203                   break;
8204               }
8205             break;
8206           case 0x8d:
8207               GETBYTE ();
8208               switch (op[2] & 0x00)
8209               {
8210                 case 0x00:
8211                   goto op_semantics_64;
8212                   break;
8213               }
8214             break;
8215           case 0x8e:
8216               GETBYTE ();
8217               switch (op[2] & 0x00)
8218               {
8219                 case 0x00:
8220                   goto op_semantics_64;
8221                   break;
8222               }
8223             break;
8224           case 0x8f:
8225               GETBYTE ();
8226               switch (op[2] & 0x00)
8227               {
8228                 case 0x00:
8229                   goto op_semantics_64;
8230                   break;
8231               }
8232             break;
8233           case 0x90:
8234               GETBYTE ();
8235               switch (op[2] & 0x00)
8236               {
8237                 case 0x00:
8238                   op_semantics_65:
8239                     {
8240                       /** 1111 1100 1001 00sd rsrc rdst fdiv    %1%S1, %0 */
8241 #line 854 "rx-decode.opc"
8242                       int sd AU = op[1] & 0x03;
8243 #line 854 "rx-decode.opc"
8244                       int rsrc AU = (op[2] >> 4) & 0x0f;
8245 #line 854 "rx-decode.opc"
8246                       int rdst AU = op[2] & 0x0f;
8247                       if (trace)
8248                         {
8249                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8250                                  "/** 1111 1100 1001 00sd rsrc rdst     fdiv    %1%S1, %0 */",
8251                                  op[0], op[1], op[2]);
8252                           printf ("  sd = 0x%x,", sd);
8253                           printf ("  rsrc = 0x%x,", rsrc);
8254                           printf ("  rdst = 0x%x\n", rdst);
8255                         }
8256                       SYNTAX("fdiv      %1%S1, %0");
8257 #line 854 "rx-decode.opc"
8258                       ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8259
8260                     }
8261                   break;
8262               }
8263             break;
8264           case 0x91:
8265               GETBYTE ();
8266               switch (op[2] & 0x00)
8267               {
8268                 case 0x00:
8269                   goto op_semantics_65;
8270                   break;
8271               }
8272             break;
8273           case 0x92:
8274               GETBYTE ();
8275               switch (op[2] & 0x00)
8276               {
8277                 case 0x00:
8278                   goto op_semantics_65;
8279                   break;
8280               }
8281             break;
8282           case 0x93:
8283               GETBYTE ();
8284               switch (op[2] & 0x00)
8285               {
8286                 case 0x00:
8287                   goto op_semantics_65;
8288                   break;
8289               }
8290             break;
8291           case 0x94:
8292               GETBYTE ();
8293               switch (op[2] & 0x00)
8294               {
8295                 case 0x00:
8296                   op_semantics_66:
8297                     {
8298                       /** 1111 1100 1001 01sd rsrc rdst ftoi    %1%S1, %0 */
8299 #line 842 "rx-decode.opc"
8300                       int sd AU = op[1] & 0x03;
8301 #line 842 "rx-decode.opc"
8302                       int rsrc AU = (op[2] >> 4) & 0x0f;
8303 #line 842 "rx-decode.opc"
8304                       int rdst AU = op[2] & 0x0f;
8305                       if (trace)
8306                         {
8307                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8308                                  "/** 1111 1100 1001 01sd rsrc rdst     ftoi    %1%S1, %0 */",
8309                                  op[0], op[1], op[2]);
8310                           printf ("  sd = 0x%x,", sd);
8311                           printf ("  rsrc = 0x%x,", rsrc);
8312                           printf ("  rdst = 0x%x\n", rdst);
8313                         }
8314                       SYNTAX("ftoi      %1%S1, %0");
8315 #line 842 "rx-decode.opc"
8316                       ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8317
8318                     }
8319                   break;
8320               }
8321             break;
8322           case 0x95:
8323               GETBYTE ();
8324               switch (op[2] & 0x00)
8325               {
8326                 case 0x00:
8327                   goto op_semantics_66;
8328                   break;
8329               }
8330             break;
8331           case 0x96:
8332               GETBYTE ();
8333               switch (op[2] & 0x00)
8334               {
8335                 case 0x00:
8336                   goto op_semantics_66;
8337                   break;
8338               }
8339             break;
8340           case 0x97:
8341               GETBYTE ();
8342               switch (op[2] & 0x00)
8343               {
8344                 case 0x00:
8345                   goto op_semantics_66;
8346                   break;
8347               }
8348             break;
8349           case 0x98:
8350               GETBYTE ();
8351               switch (op[2] & 0x00)
8352               {
8353                 case 0x00:
8354                   op_semantics_67:
8355                     {
8356                       /** 1111 1100 1001 10sd rsrc rdst round   %1%S1, %0 */
8357 #line 857 "rx-decode.opc"
8358                       int sd AU = op[1] & 0x03;
8359 #line 857 "rx-decode.opc"
8360                       int rsrc AU = (op[2] >> 4) & 0x0f;
8361 #line 857 "rx-decode.opc"
8362                       int rdst AU = op[2] & 0x0f;
8363                       if (trace)
8364                         {
8365                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8366                                  "/** 1111 1100 1001 10sd rsrc rdst     round   %1%S1, %0 */",
8367                                  op[0], op[1], op[2]);
8368                           printf ("  sd = 0x%x,", sd);
8369                           printf ("  rsrc = 0x%x,", rsrc);
8370                           printf ("  rdst = 0x%x\n", rdst);
8371                         }
8372                       SYNTAX("round     %1%S1, %0");
8373 #line 857 "rx-decode.opc"
8374                       ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F("-SZ-");
8375
8376                     }
8377                   break;
8378               }
8379             break;
8380           case 0x99:
8381               GETBYTE ();
8382               switch (op[2] & 0x00)
8383               {
8384                 case 0x00:
8385                   goto op_semantics_67;
8386                   break;
8387               }
8388             break;
8389           case 0x9a:
8390               GETBYTE ();
8391               switch (op[2] & 0x00)
8392               {
8393                 case 0x00:
8394                   goto op_semantics_67;
8395                   break;
8396               }
8397             break;
8398           case 0x9b:
8399               GETBYTE ();
8400               switch (op[2] & 0x00)
8401               {
8402                 case 0x00:
8403                   goto op_semantics_67;
8404                   break;
8405               }
8406             break;
8407           case 0xd0:
8408               GETBYTE ();
8409               switch (op[2] & 0x00)
8410               {
8411                 case 0x00:
8412                   op_semantics_68:
8413                     {
8414                       /** 1111 1100 1101 sz sd rdst cond        sc%1%s  %0 */
8415 #line 966 "rx-decode.opc"
8416                       int sz AU = (op[1] >> 2) & 0x03;
8417 #line 966 "rx-decode.opc"
8418                       int sd AU = op[1] & 0x03;
8419 #line 966 "rx-decode.opc"
8420                       int rdst AU = (op[2] >> 4) & 0x0f;
8421 #line 966 "rx-decode.opc"
8422                       int cond AU = op[2] & 0x0f;
8423                       if (trace)
8424                         {
8425                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8426                                  "/** 1111 1100 1101 sz sd rdst cond    sc%1%s  %0 */",
8427                                  op[0], op[1], op[2]);
8428                           printf ("  sz = 0x%x,", sz);
8429                           printf ("  sd = 0x%x,", sd);
8430                           printf ("  rdst = 0x%x,", rdst);
8431                           printf ("  cond = 0x%x\n", cond);
8432                         }
8433                       SYNTAX("sc%1%s    %0");
8434 #line 966 "rx-decode.opc"
8435                       ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8436
8437                     }
8438                   break;
8439               }
8440             break;
8441           case 0xd1:
8442               GETBYTE ();
8443               switch (op[2] & 0x00)
8444               {
8445                 case 0x00:
8446                   goto op_semantics_68;
8447                   break;
8448               }
8449             break;
8450           case 0xd2:
8451               GETBYTE ();
8452               switch (op[2] & 0x00)
8453               {
8454                 case 0x00:
8455                   goto op_semantics_68;
8456                   break;
8457               }
8458             break;
8459           case 0xd3:
8460               GETBYTE ();
8461               switch (op[2] & 0x00)
8462               {
8463                 case 0x00:
8464                   goto op_semantics_68;
8465                   break;
8466               }
8467             break;
8468           case 0xd4:
8469               GETBYTE ();
8470               switch (op[2] & 0x00)
8471               {
8472                 case 0x00:
8473                   goto op_semantics_68;
8474                   break;
8475               }
8476             break;
8477           case 0xd5:
8478               GETBYTE ();
8479               switch (op[2] & 0x00)
8480               {
8481                 case 0x00:
8482                   goto op_semantics_68;
8483                   break;
8484               }
8485             break;
8486           case 0xd6:
8487               GETBYTE ();
8488               switch (op[2] & 0x00)
8489               {
8490                 case 0x00:
8491                   goto op_semantics_68;
8492                   break;
8493               }
8494             break;
8495           case 0xd7:
8496               GETBYTE ();
8497               switch (op[2] & 0x00)
8498               {
8499                 case 0x00:
8500                   goto op_semantics_68;
8501                   break;
8502               }
8503             break;
8504           case 0xd8:
8505               GETBYTE ();
8506               switch (op[2] & 0x00)
8507               {
8508                 case 0x00:
8509                   goto op_semantics_68;
8510                   break;
8511               }
8512             break;
8513           case 0xd9:
8514               GETBYTE ();
8515               switch (op[2] & 0x00)
8516               {
8517                 case 0x00:
8518                   goto op_semantics_68;
8519                   break;
8520               }
8521             break;
8522           case 0xda:
8523               GETBYTE ();
8524               switch (op[2] & 0x00)
8525               {
8526                 case 0x00:
8527                   goto op_semantics_68;
8528                   break;
8529               }
8530             break;
8531           case 0xdb:
8532               GETBYTE ();
8533               switch (op[2] & 0x00)
8534               {
8535                 case 0x00:
8536                   goto op_semantics_68;
8537                   break;
8538               }
8539             break;
8540           case 0xe0:
8541               GETBYTE ();
8542               switch (op[2] & 0x0f)
8543               {
8544                 case 0x00:
8545                 case 0x01:
8546                 case 0x02:
8547                 case 0x03:
8548                 case 0x04:
8549                 case 0x05:
8550                 case 0x06:
8551                 case 0x07:
8552                 case 0x08:
8553                 case 0x09:
8554                 case 0x0a:
8555                 case 0x0b:
8556                 case 0x0c:
8557                 case 0x0d:
8558                 case 0x0e:
8559                   op_semantics_69:
8560                     {
8561                       /** 1111 1100 111bit sd rdst cond bm%2    #%1, %0%S0 */
8562 #line 909 "rx-decode.opc"
8563                       int bit AU = (op[1] >> 2) & 0x07;
8564 #line 909 "rx-decode.opc"
8565                       int sd AU = op[1] & 0x03;
8566 #line 909 "rx-decode.opc"
8567                       int rdst AU = (op[2] >> 4) & 0x0f;
8568 #line 909 "rx-decode.opc"
8569                       int cond AU = op[2] & 0x0f;
8570                       if (trace)
8571                         {
8572                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8573                                  "/** 1111 1100 111bit sd rdst cond     bm%2    #%1, %0%S0 */",
8574                                  op[0], op[1], op[2]);
8575                           printf ("  bit = 0x%x,", bit);
8576                           printf ("  sd = 0x%x,", sd);
8577                           printf ("  rdst = 0x%x,", rdst);
8578                           printf ("  cond = 0x%x\n", cond);
8579                         }
8580                       SYNTAX("bm%2      #%1, %0%S0");
8581 #line 909 "rx-decode.opc"
8582                       ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
8583
8584                     }
8585                   break;
8586                 case 0x0f:
8587                   op_semantics_70:
8588                     {
8589                       /** 1111 1100 111bit sd rdst 1111 bnot    #%1, %0%S0 */
8590 #line 899 "rx-decode.opc"
8591                       int bit AU = (op[1] >> 2) & 0x07;
8592 #line 899 "rx-decode.opc"
8593                       int sd AU = op[1] & 0x03;
8594 #line 899 "rx-decode.opc"
8595                       int rdst AU = (op[2] >> 4) & 0x0f;
8596                       if (trace)
8597                         {
8598                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8599                                  "/** 1111 1100 111bit sd rdst 1111     bnot    #%1, %0%S0 */",
8600                                  op[0], op[1], op[2]);
8601                           printf ("  bit = 0x%x,", bit);
8602                           printf ("  sd = 0x%x,", sd);
8603                           printf ("  rdst = 0x%x\n", rdst);
8604                         }
8605                       SYNTAX("bnot      #%1, %0%S0");
8606 #line 899 "rx-decode.opc"
8607                       ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
8608
8609                     }
8610                   break;
8611               }
8612             break;
8613           case 0xe1:
8614               GETBYTE ();
8615               switch (op[2] & 0x0f)
8616               {
8617                 case 0x00:
8618                 case 0x01:
8619                 case 0x02:
8620                 case 0x03:
8621                 case 0x04:
8622                 case 0x05:
8623                 case 0x06:
8624                 case 0x07:
8625                 case 0x08:
8626                 case 0x09:
8627                 case 0x0a:
8628                 case 0x0b:
8629                 case 0x0c:
8630                 case 0x0d:
8631                 case 0x0e:
8632                   goto op_semantics_69;
8633                   break;
8634                 case 0x0f:
8635                   goto op_semantics_70;
8636                   break;
8637               }
8638             break;
8639           case 0xe2:
8640               GETBYTE ();
8641               switch (op[2] & 0x0f)
8642               {
8643                 case 0x00:
8644                 case 0x01:
8645                 case 0x02:
8646                 case 0x03:
8647                 case 0x04:
8648                 case 0x05:
8649                 case 0x06:
8650                 case 0x07:
8651                 case 0x08:
8652                 case 0x09:
8653                 case 0x0a:
8654                 case 0x0b:
8655                 case 0x0c:
8656                 case 0x0d:
8657                 case 0x0e:
8658                   goto op_semantics_69;
8659                   break;
8660                 case 0x0f:
8661                   goto op_semantics_70;
8662                   break;
8663               }
8664             break;
8665           case 0xe3:
8666               GETBYTE ();
8667               switch (op[2] & 0x0f)
8668               {
8669                 case 0x00:
8670                 case 0x01:
8671                 case 0x02:
8672                 case 0x03:
8673                 case 0x04:
8674                 case 0x05:
8675                 case 0x06:
8676                 case 0x07:
8677                 case 0x08:
8678                 case 0x09:
8679                 case 0x0a:
8680                 case 0x0b:
8681                 case 0x0c:
8682                 case 0x0d:
8683                 case 0x0e:
8684                   goto op_semantics_69;
8685                   break;
8686                 case 0x0f:
8687                   goto op_semantics_70;
8688                   break;
8689               }
8690             break;
8691           case 0xe4:
8692               GETBYTE ();
8693               switch (op[2] & 0x0f)
8694               {
8695                 case 0x00:
8696                 case 0x01:
8697                 case 0x02:
8698                 case 0x03:
8699                 case 0x04:
8700                 case 0x05:
8701                 case 0x06:
8702                 case 0x07:
8703                 case 0x08:
8704                 case 0x09:
8705                 case 0x0a:
8706                 case 0x0b:
8707                 case 0x0c:
8708                 case 0x0d:
8709                 case 0x0e:
8710                   goto op_semantics_69;
8711                   break;
8712                 case 0x0f:
8713                   goto op_semantics_70;
8714                   break;
8715               }
8716             break;
8717           case 0xe5:
8718               GETBYTE ();
8719               switch (op[2] & 0x0f)
8720               {
8721                 case 0x00:
8722                 case 0x01:
8723                 case 0x02:
8724                 case 0x03:
8725                 case 0x04:
8726                 case 0x05:
8727                 case 0x06:
8728                 case 0x07:
8729                 case 0x08:
8730                 case 0x09:
8731                 case 0x0a:
8732                 case 0x0b:
8733                 case 0x0c:
8734                 case 0x0d:
8735                 case 0x0e:
8736                   goto op_semantics_69;
8737                   break;
8738                 case 0x0f:
8739                   goto op_semantics_70;
8740                   break;
8741               }
8742             break;
8743           case 0xe6:
8744               GETBYTE ();
8745               switch (op[2] & 0x0f)
8746               {
8747                 case 0x00:
8748                 case 0x01:
8749                 case 0x02:
8750                 case 0x03:
8751                 case 0x04:
8752                 case 0x05:
8753                 case 0x06:
8754                 case 0x07:
8755                 case 0x08:
8756                 case 0x09:
8757                 case 0x0a:
8758                 case 0x0b:
8759                 case 0x0c:
8760                 case 0x0d:
8761                 case 0x0e:
8762                   goto op_semantics_69;
8763                   break;
8764                 case 0x0f:
8765                   goto op_semantics_70;
8766                   break;
8767               }
8768             break;
8769           case 0xe7:
8770               GETBYTE ();
8771               switch (op[2] & 0x0f)
8772               {
8773                 case 0x00:
8774                 case 0x01:
8775                 case 0x02:
8776                 case 0x03:
8777                 case 0x04:
8778                 case 0x05:
8779                 case 0x06:
8780                 case 0x07:
8781                 case 0x08:
8782                 case 0x09:
8783                 case 0x0a:
8784                 case 0x0b:
8785                 case 0x0c:
8786                 case 0x0d:
8787                 case 0x0e:
8788                   goto op_semantics_69;
8789                   break;
8790                 case 0x0f:
8791                   goto op_semantics_70;
8792                   break;
8793               }
8794             break;
8795           case 0xe8:
8796               GETBYTE ();
8797               switch (op[2] & 0x0f)
8798               {
8799                 case 0x00:
8800                 case 0x01:
8801                 case 0x02:
8802                 case 0x03:
8803                 case 0x04:
8804                 case 0x05:
8805                 case 0x06:
8806                 case 0x07:
8807                 case 0x08:
8808                 case 0x09:
8809                 case 0x0a:
8810                 case 0x0b:
8811                 case 0x0c:
8812                 case 0x0d:
8813                 case 0x0e:
8814                   goto op_semantics_69;
8815                   break;
8816                 case 0x0f:
8817                   goto op_semantics_70;
8818                   break;
8819               }
8820             break;
8821           case 0xe9:
8822               GETBYTE ();
8823               switch (op[2] & 0x0f)
8824               {
8825                 case 0x00:
8826                 case 0x01:
8827                 case 0x02:
8828                 case 0x03:
8829                 case 0x04:
8830                 case 0x05:
8831                 case 0x06:
8832                 case 0x07:
8833                 case 0x08:
8834                 case 0x09:
8835                 case 0x0a:
8836                 case 0x0b:
8837                 case 0x0c:
8838                 case 0x0d:
8839                 case 0x0e:
8840                   goto op_semantics_69;
8841                   break;
8842                 case 0x0f:
8843                   goto op_semantics_70;
8844                   break;
8845               }
8846             break;
8847           case 0xea:
8848               GETBYTE ();
8849               switch (op[2] & 0x0f)
8850               {
8851                 case 0x00:
8852                 case 0x01:
8853                 case 0x02:
8854                 case 0x03:
8855                 case 0x04:
8856                 case 0x05:
8857                 case 0x06:
8858                 case 0x07:
8859                 case 0x08:
8860                 case 0x09:
8861                 case 0x0a:
8862                 case 0x0b:
8863                 case 0x0c:
8864                 case 0x0d:
8865                 case 0x0e:
8866                   goto op_semantics_69;
8867                   break;
8868                 case 0x0f:
8869                   goto op_semantics_70;
8870                   break;
8871               }
8872             break;
8873           case 0xeb:
8874               GETBYTE ();
8875               switch (op[2] & 0x0f)
8876               {
8877                 case 0x00:
8878                 case 0x01:
8879                 case 0x02:
8880                 case 0x03:
8881                 case 0x04:
8882                 case 0x05:
8883                 case 0x06:
8884                 case 0x07:
8885                 case 0x08:
8886                 case 0x09:
8887                 case 0x0a:
8888                 case 0x0b:
8889                 case 0x0c:
8890                 case 0x0d:
8891                 case 0x0e:
8892                   goto op_semantics_69;
8893                   break;
8894                 case 0x0f:
8895                   goto op_semantics_70;
8896                   break;
8897               }
8898             break;
8899           case 0xec:
8900               GETBYTE ();
8901               switch (op[2] & 0x0f)
8902               {
8903                 case 0x00:
8904                 case 0x01:
8905                 case 0x02:
8906                 case 0x03:
8907                 case 0x04:
8908                 case 0x05:
8909                 case 0x06:
8910                 case 0x07:
8911                 case 0x08:
8912                 case 0x09:
8913                 case 0x0a:
8914                 case 0x0b:
8915                 case 0x0c:
8916                 case 0x0d:
8917                 case 0x0e:
8918                   goto op_semantics_69;
8919                   break;
8920                 case 0x0f:
8921                   goto op_semantics_70;
8922                   break;
8923               }
8924             break;
8925           case 0xed:
8926               GETBYTE ();
8927               switch (op[2] & 0x0f)
8928               {
8929                 case 0x00:
8930                 case 0x01:
8931                 case 0x02:
8932                 case 0x03:
8933                 case 0x04:
8934                 case 0x05:
8935                 case 0x06:
8936                 case 0x07:
8937                 case 0x08:
8938                 case 0x09:
8939                 case 0x0a:
8940                 case 0x0b:
8941                 case 0x0c:
8942                 case 0x0d:
8943                 case 0x0e:
8944                   goto op_semantics_69;
8945                   break;
8946                 case 0x0f:
8947                   goto op_semantics_70;
8948                   break;
8949               }
8950             break;
8951           case 0xee:
8952               GETBYTE ();
8953               switch (op[2] & 0x0f)
8954               {
8955                 case 0x00:
8956                 case 0x01:
8957                 case 0x02:
8958                 case 0x03:
8959                 case 0x04:
8960                 case 0x05:
8961                 case 0x06:
8962                 case 0x07:
8963                 case 0x08:
8964                 case 0x09:
8965                 case 0x0a:
8966                 case 0x0b:
8967                 case 0x0c:
8968                 case 0x0d:
8969                 case 0x0e:
8970                   goto op_semantics_69;
8971                   break;
8972                 case 0x0f:
8973                   goto op_semantics_70;
8974                   break;
8975               }
8976             break;
8977           case 0xef:
8978               GETBYTE ();
8979               switch (op[2] & 0x0f)
8980               {
8981                 case 0x00:
8982                 case 0x01:
8983                 case 0x02:
8984                 case 0x03:
8985                 case 0x04:
8986                 case 0x05:
8987                 case 0x06:
8988                 case 0x07:
8989                 case 0x08:
8990                 case 0x09:
8991                 case 0x0a:
8992                 case 0x0b:
8993                 case 0x0c:
8994                 case 0x0d:
8995                 case 0x0e:
8996                   goto op_semantics_69;
8997                   break;
8998                 case 0x0f:
8999                   goto op_semantics_70;
9000                   break;
9001               }
9002             break;
9003           case 0xf0:
9004               GETBYTE ();
9005               switch (op[2] & 0x0f)
9006               {
9007                 case 0x00:
9008                 case 0x01:
9009                 case 0x02:
9010                 case 0x03:
9011                 case 0x04:
9012                 case 0x05:
9013                 case 0x06:
9014                 case 0x07:
9015                 case 0x08:
9016                 case 0x09:
9017                 case 0x0a:
9018                 case 0x0b:
9019                 case 0x0c:
9020                 case 0x0d:
9021                 case 0x0e:
9022                   goto op_semantics_69;
9023                   break;
9024                 case 0x0f:
9025                   goto op_semantics_70;
9026                   break;
9027               }
9028             break;
9029           case 0xf1:
9030               GETBYTE ();
9031               switch (op[2] & 0x0f)
9032               {
9033                 case 0x00:
9034                 case 0x01:
9035                 case 0x02:
9036                 case 0x03:
9037                 case 0x04:
9038                 case 0x05:
9039                 case 0x06:
9040                 case 0x07:
9041                 case 0x08:
9042                 case 0x09:
9043                 case 0x0a:
9044                 case 0x0b:
9045                 case 0x0c:
9046                 case 0x0d:
9047                 case 0x0e:
9048                   goto op_semantics_69;
9049                   break;
9050                 case 0x0f:
9051                   goto op_semantics_70;
9052                   break;
9053               }
9054             break;
9055           case 0xf2:
9056               GETBYTE ();
9057               switch (op[2] & 0x0f)
9058               {
9059                 case 0x00:
9060                 case 0x01:
9061                 case 0x02:
9062                 case 0x03:
9063                 case 0x04:
9064                 case 0x05:
9065                 case 0x06:
9066                 case 0x07:
9067                 case 0x08:
9068                 case 0x09:
9069                 case 0x0a:
9070                 case 0x0b:
9071                 case 0x0c:
9072                 case 0x0d:
9073                 case 0x0e:
9074                   goto op_semantics_69;
9075                   break;
9076                 case 0x0f:
9077                   goto op_semantics_70;
9078                   break;
9079               }
9080             break;
9081           case 0xf3:
9082               GETBYTE ();
9083               switch (op[2] & 0x0f)
9084               {
9085                 case 0x00:
9086                 case 0x01:
9087                 case 0x02:
9088                 case 0x03:
9089                 case 0x04:
9090                 case 0x05:
9091                 case 0x06:
9092                 case 0x07:
9093                 case 0x08:
9094                 case 0x09:
9095                 case 0x0a:
9096                 case 0x0b:
9097                 case 0x0c:
9098                 case 0x0d:
9099                 case 0x0e:
9100                   goto op_semantics_69;
9101                   break;
9102                 case 0x0f:
9103                   goto op_semantics_70;
9104                   break;
9105               }
9106             break;
9107           case 0xf4:
9108               GETBYTE ();
9109               switch (op[2] & 0x0f)
9110               {
9111                 case 0x00:
9112                 case 0x01:
9113                 case 0x02:
9114                 case 0x03:
9115                 case 0x04:
9116                 case 0x05:
9117                 case 0x06:
9118                 case 0x07:
9119                 case 0x08:
9120                 case 0x09:
9121                 case 0x0a:
9122                 case 0x0b:
9123                 case 0x0c:
9124                 case 0x0d:
9125                 case 0x0e:
9126                   goto op_semantics_69;
9127                   break;
9128                 case 0x0f:
9129                   goto op_semantics_70;
9130                   break;
9131               }
9132             break;
9133           case 0xf5:
9134               GETBYTE ();
9135               switch (op[2] & 0x0f)
9136               {
9137                 case 0x00:
9138                 case 0x01:
9139                 case 0x02:
9140                 case 0x03:
9141                 case 0x04:
9142                 case 0x05:
9143                 case 0x06:
9144                 case 0x07:
9145                 case 0x08:
9146                 case 0x09:
9147                 case 0x0a:
9148                 case 0x0b:
9149                 case 0x0c:
9150                 case 0x0d:
9151                 case 0x0e:
9152                   goto op_semantics_69;
9153                   break;
9154                 case 0x0f:
9155                   goto op_semantics_70;
9156                   break;
9157               }
9158             break;
9159           case 0xf6:
9160               GETBYTE ();
9161               switch (op[2] & 0x0f)
9162               {
9163                 case 0x00:
9164                 case 0x01:
9165                 case 0x02:
9166                 case 0x03:
9167                 case 0x04:
9168                 case 0x05:
9169                 case 0x06:
9170                 case 0x07:
9171                 case 0x08:
9172                 case 0x09:
9173                 case 0x0a:
9174                 case 0x0b:
9175                 case 0x0c:
9176                 case 0x0d:
9177                 case 0x0e:
9178                   goto op_semantics_69;
9179                   break;
9180                 case 0x0f:
9181                   goto op_semantics_70;
9182                   break;
9183               }
9184             break;
9185           case 0xf7:
9186               GETBYTE ();
9187               switch (op[2] & 0x0f)
9188               {
9189                 case 0x00:
9190                 case 0x01:
9191                 case 0x02:
9192                 case 0x03:
9193                 case 0x04:
9194                 case 0x05:
9195                 case 0x06:
9196                 case 0x07:
9197                 case 0x08:
9198                 case 0x09:
9199                 case 0x0a:
9200                 case 0x0b:
9201                 case 0x0c:
9202                 case 0x0d:
9203                 case 0x0e:
9204                   goto op_semantics_69;
9205                   break;
9206                 case 0x0f:
9207                   goto op_semantics_70;
9208                   break;
9209               }
9210             break;
9211           case 0xf8:
9212               GETBYTE ();
9213               switch (op[2] & 0x0f)
9214               {
9215                 case 0x00:
9216                 case 0x01:
9217                 case 0x02:
9218                 case 0x03:
9219                 case 0x04:
9220                 case 0x05:
9221                 case 0x06:
9222                 case 0x07:
9223                 case 0x08:
9224                 case 0x09:
9225                 case 0x0a:
9226                 case 0x0b:
9227                 case 0x0c:
9228                 case 0x0d:
9229                 case 0x0e:
9230                   goto op_semantics_69;
9231                   break;
9232                 case 0x0f:
9233                   goto op_semantics_70;
9234                   break;
9235               }
9236             break;
9237           case 0xf9:
9238               GETBYTE ();
9239               switch (op[2] & 0x0f)
9240               {
9241                 case 0x00:
9242                 case 0x01:
9243                 case 0x02:
9244                 case 0x03:
9245                 case 0x04:
9246                 case 0x05:
9247                 case 0x06:
9248                 case 0x07:
9249                 case 0x08:
9250                 case 0x09:
9251                 case 0x0a:
9252                 case 0x0b:
9253                 case 0x0c:
9254                 case 0x0d:
9255                 case 0x0e:
9256                   goto op_semantics_69;
9257                   break;
9258                 case 0x0f:
9259                   goto op_semantics_70;
9260                   break;
9261               }
9262             break;
9263           case 0xfa:
9264               GETBYTE ();
9265               switch (op[2] & 0x0f)
9266               {
9267                 case 0x00:
9268                 case 0x01:
9269                 case 0x02:
9270                 case 0x03:
9271                 case 0x04:
9272                 case 0x05:
9273                 case 0x06:
9274                 case 0x07:
9275                 case 0x08:
9276                 case 0x09:
9277                 case 0x0a:
9278                 case 0x0b:
9279                 case 0x0c:
9280                 case 0x0d:
9281                 case 0x0e:
9282                   goto op_semantics_69;
9283                   break;
9284                 case 0x0f:
9285                   goto op_semantics_70;
9286                   break;
9287               }
9288             break;
9289           case 0xfb:
9290               GETBYTE ();
9291               switch (op[2] & 0x0f)
9292               {
9293                 case 0x00:
9294                 case 0x01:
9295                 case 0x02:
9296                 case 0x03:
9297                 case 0x04:
9298                 case 0x05:
9299                 case 0x06:
9300                 case 0x07:
9301                 case 0x08:
9302                 case 0x09:
9303                 case 0x0a:
9304                 case 0x0b:
9305                 case 0x0c:
9306                 case 0x0d:
9307                 case 0x0e:
9308                   goto op_semantics_69;
9309                   break;
9310                 case 0x0f:
9311                   goto op_semantics_70;
9312                   break;
9313               }
9314             break;
9315           case 0xfc:
9316               GETBYTE ();
9317               switch (op[2] & 0x0f)
9318               {
9319                 case 0x00:
9320                 case 0x01:
9321                 case 0x02:
9322                 case 0x03:
9323                 case 0x04:
9324                 case 0x05:
9325                 case 0x06:
9326                 case 0x07:
9327                 case 0x08:
9328                 case 0x09:
9329                 case 0x0a:
9330                 case 0x0b:
9331                 case 0x0c:
9332                 case 0x0d:
9333                 case 0x0e:
9334                   goto op_semantics_69;
9335                   break;
9336                 case 0x0f:
9337                   goto op_semantics_70;
9338                   break;
9339               }
9340             break;
9341           case 0xfd:
9342               GETBYTE ();
9343               switch (op[2] & 0x0f)
9344               {
9345                 case 0x00:
9346                 case 0x01:
9347                 case 0x02:
9348                 case 0x03:
9349                 case 0x04:
9350                 case 0x05:
9351                 case 0x06:
9352                 case 0x07:
9353                 case 0x08:
9354                 case 0x09:
9355                 case 0x0a:
9356                 case 0x0b:
9357                 case 0x0c:
9358                 case 0x0d:
9359                 case 0x0e:
9360                   goto op_semantics_69;
9361                   break;
9362                 case 0x0f:
9363                   goto op_semantics_70;
9364                   break;
9365               }
9366             break;
9367           case 0xfe:
9368               GETBYTE ();
9369               switch (op[2] & 0x0f)
9370               {
9371                 case 0x00:
9372                 case 0x01:
9373                 case 0x02:
9374                 case 0x03:
9375                 case 0x04:
9376                 case 0x05:
9377                 case 0x06:
9378                 case 0x07:
9379                 case 0x08:
9380                 case 0x09:
9381                 case 0x0a:
9382                 case 0x0b:
9383                 case 0x0c:
9384                 case 0x0d:
9385                 case 0x0e:
9386                   goto op_semantics_69;
9387                   break;
9388                 case 0x0f:
9389                   goto op_semantics_70;
9390                   break;
9391               }
9392             break;
9393           case 0xff:
9394               GETBYTE ();
9395               switch (op[2] & 0x0f)
9396               {
9397                 case 0x00:
9398                 case 0x01:
9399                 case 0x02:
9400                 case 0x03:
9401                 case 0x04:
9402                 case 0x05:
9403                 case 0x06:
9404                 case 0x07:
9405                 case 0x08:
9406                 case 0x09:
9407                 case 0x0a:
9408                 case 0x0b:
9409                 case 0x0c:
9410                 case 0x0d:
9411                 case 0x0e:
9412                   goto op_semantics_69;
9413                   break;
9414                 case 0x0f:
9415                   goto op_semantics_70;
9416                   break;
9417               }
9418             break;
9419           default: UNSUPPORTED(); break;
9420         }
9421       break;
9422     case 0xfd:
9423         GETBYTE ();
9424         switch (op[1] & 0xff)
9425         {
9426           case 0x00:
9427               GETBYTE ();
9428               switch (op[2] & 0x00)
9429               {
9430                 case 0x00:
9431                     {
9432                       /** 1111 1101 0000 0000 srca srcb mulhi   %1, %2 */
9433 #line 782 "rx-decode.opc"
9434                       int srca AU = (op[2] >> 4) & 0x0f;
9435 #line 782 "rx-decode.opc"
9436                       int srcb AU = op[2] & 0x0f;
9437                       if (trace)
9438                         {
9439                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9440                                  "/** 1111 1101 0000 0000 srca srcb     mulhi   %1, %2 */",
9441                                  op[0], op[1], op[2]);
9442                           printf ("  srca = 0x%x,", srca);
9443                           printf ("  srcb = 0x%x\n", srcb);
9444                         }
9445                       SYNTAX("mulhi     %1, %2");
9446 #line 782 "rx-decode.opc"
9447                       ID(mulhi); SR(srca); S2R(srcb); F("----");
9448
9449                     }
9450                   break;
9451               }
9452             break;
9453           case 0x01:
9454               GETBYTE ();
9455               switch (op[2] & 0x00)
9456               {
9457                 case 0x00:
9458                     {
9459                       /** 1111 1101 0000 0001 srca srcb mullo   %1, %2 */
9460 #line 785 "rx-decode.opc"
9461                       int srca AU = (op[2] >> 4) & 0x0f;
9462 #line 785 "rx-decode.opc"
9463                       int srcb AU = op[2] & 0x0f;
9464                       if (trace)
9465                         {
9466                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9467                                  "/** 1111 1101 0000 0001 srca srcb     mullo   %1, %2 */",
9468                                  op[0], op[1], op[2]);
9469                           printf ("  srca = 0x%x,", srca);
9470                           printf ("  srcb = 0x%x\n", srcb);
9471                         }
9472                       SYNTAX("mullo     %1, %2");
9473 #line 785 "rx-decode.opc"
9474                       ID(mullo); SR(srca); S2R(srcb); F("----");
9475
9476                     }
9477                   break;
9478               }
9479             break;
9480           case 0x04:
9481               GETBYTE ();
9482               switch (op[2] & 0x00)
9483               {
9484                 case 0x00:
9485                     {
9486                       /** 1111 1101 0000 0100 srca srcb machi   %1, %2 */
9487 #line 788 "rx-decode.opc"
9488                       int srca AU = (op[2] >> 4) & 0x0f;
9489 #line 788 "rx-decode.opc"
9490                       int srcb AU = op[2] & 0x0f;
9491                       if (trace)
9492                         {
9493                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9494                                  "/** 1111 1101 0000 0100 srca srcb     machi   %1, %2 */",
9495                                  op[0], op[1], op[2]);
9496                           printf ("  srca = 0x%x,", srca);
9497                           printf ("  srcb = 0x%x\n", srcb);
9498                         }
9499                       SYNTAX("machi     %1, %2");
9500 #line 788 "rx-decode.opc"
9501                       ID(machi); SR(srca); S2R(srcb); F("----");
9502
9503                     }
9504                   break;
9505               }
9506             break;
9507           case 0x05:
9508               GETBYTE ();
9509               switch (op[2] & 0x00)
9510               {
9511                 case 0x00:
9512                     {
9513                       /** 1111 1101 0000 0101 srca srcb maclo   %1, %2 */
9514 #line 791 "rx-decode.opc"
9515                       int srca AU = (op[2] >> 4) & 0x0f;
9516 #line 791 "rx-decode.opc"
9517                       int srcb AU = op[2] & 0x0f;
9518                       if (trace)
9519                         {
9520                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9521                                  "/** 1111 1101 0000 0101 srca srcb     maclo   %1, %2 */",
9522                                  op[0], op[1], op[2]);
9523                           printf ("  srca = 0x%x,", srca);
9524                           printf ("  srcb = 0x%x\n", srcb);
9525                         }
9526                       SYNTAX("maclo     %1, %2");
9527 #line 791 "rx-decode.opc"
9528                       ID(maclo); SR(srca); S2R(srcb); F("----");
9529
9530                     }
9531                   break;
9532               }
9533             break;
9534           case 0x17:
9535               GETBYTE ();
9536               switch (op[2] & 0xf0)
9537               {
9538                 case 0x00:
9539                     {
9540                       /** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */
9541 #line 794 "rx-decode.opc"
9542                       int rsrc AU = op[2] & 0x0f;
9543                       if (trace)
9544                         {
9545                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9546                                  "/** 1111 1101 0001 0111 0000 rsrc     mvtachi %1 */",
9547                                  op[0], op[1], op[2]);
9548                           printf ("  rsrc = 0x%x\n", rsrc);
9549                         }
9550                       SYNTAX("mvtachi   %1");
9551 #line 794 "rx-decode.opc"
9552                       ID(mvtachi); SR(rsrc); F("----");
9553
9554                     }
9555                   break;
9556                 case 0x10:
9557                     {
9558                       /** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */
9559 #line 797 "rx-decode.opc"
9560                       int rsrc AU = op[2] & 0x0f;
9561                       if (trace)
9562                         {
9563                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9564                                  "/** 1111 1101 0001 0111 0001 rsrc     mvtaclo %1 */",
9565                                  op[0], op[1], op[2]);
9566                           printf ("  rsrc = 0x%x\n", rsrc);
9567                         }
9568                       SYNTAX("mvtaclo   %1");
9569 #line 797 "rx-decode.opc"
9570                       ID(mvtaclo); SR(rsrc); F("----");
9571
9572                     }
9573                   break;
9574                 default: UNSUPPORTED(); break;
9575               }
9576             break;
9577           case 0x18:
9578               GETBYTE ();
9579               switch (op[2] & 0xef)
9580               {
9581                 case 0x00:
9582                     {
9583                       /** 1111 1101 0001 1000 000i 0000 racw    #%1 */
9584 #line 809 "rx-decode.opc"
9585                       int i AU = (op[2] >> 4) & 0x01;
9586                       if (trace)
9587                         {
9588                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9589                                  "/** 1111 1101 0001 1000 000i 0000     racw    #%1 */",
9590                                  op[0], op[1], op[2]);
9591                           printf ("  i = 0x%x\n", i);
9592                         }
9593                       SYNTAX("racw      #%1");
9594 #line 809 "rx-decode.opc"
9595                       ID(racw); SC(i+1); F("----");
9596
9597                     /*----------------------------------------------------------------------*/
9598                     /* SAT                                                                      */
9599
9600                     }
9601                   break;
9602                 default: UNSUPPORTED(); break;
9603               }
9604             break;
9605           case 0x1f:
9606               GETBYTE ();
9607               switch (op[2] & 0xf0)
9608               {
9609                 case 0x00:
9610                     {
9611                       /** 1111 1101 0001 1111 0000 rdst mvfachi %0 */
9612 #line 800 "rx-decode.opc"
9613                       int rdst AU = op[2] & 0x0f;
9614                       if (trace)
9615                         {
9616                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9617                                  "/** 1111 1101 0001 1111 0000 rdst     mvfachi %0 */",
9618                                  op[0], op[1], op[2]);
9619                           printf ("  rdst = 0x%x\n", rdst);
9620                         }
9621                       SYNTAX("mvfachi   %0");
9622 #line 800 "rx-decode.opc"
9623                       ID(mvfachi); DR(rdst); F("----");
9624
9625                     }
9626                   break;
9627                 case 0x10:
9628                     {
9629                       /** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */
9630 #line 806 "rx-decode.opc"
9631                       int rdst AU = op[2] & 0x0f;
9632                       if (trace)
9633                         {
9634                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9635                                  "/** 1111 1101 0001 1111 0001 rdst     mvfaclo %0 */",
9636                                  op[0], op[1], op[2]);
9637                           printf ("  rdst = 0x%x\n", rdst);
9638                         }
9639                       SYNTAX("mvfaclo   %0");
9640 #line 806 "rx-decode.opc"
9641                       ID(mvfaclo); DR(rdst); F("----");
9642
9643                     }
9644                   break;
9645                 case 0x20:
9646                     {
9647                       /** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */
9648 #line 803 "rx-decode.opc"
9649                       int rdst AU = op[2] & 0x0f;
9650                       if (trace)
9651                         {
9652                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9653                                  "/** 1111 1101 0001 1111 0010 rdst     mvfacmi %0 */",
9654                                  op[0], op[1], op[2]);
9655                           printf ("  rdst = 0x%x\n", rdst);
9656                         }
9657                       SYNTAX("mvfacmi   %0");
9658 #line 803 "rx-decode.opc"
9659                       ID(mvfacmi); DR(rdst); F("----");
9660
9661                     }
9662                   break;
9663                 default: UNSUPPORTED(); break;
9664               }
9665             break;
9666           case 0x20:
9667               GETBYTE ();
9668               switch (op[2] & 0x00)
9669               {
9670                 case 0x00:
9671                   op_semantics_71:
9672                     {
9673                       /** 1111 1101 0010 0p sz rdst rsrc        mov%s   %1, %0 */
9674 #line 324 "rx-decode.opc"
9675                       int p AU = (op[1] >> 2) & 0x01;
9676 #line 324 "rx-decode.opc"
9677                       int sz AU = op[1] & 0x03;
9678 #line 324 "rx-decode.opc"
9679                       int rdst AU = (op[2] >> 4) & 0x0f;
9680 #line 324 "rx-decode.opc"
9681                       int rsrc AU = op[2] & 0x0f;
9682                       if (trace)
9683                         {
9684                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9685                                  "/** 1111 1101 0010 0p sz rdst rsrc    mov%s   %1, %0 */",
9686                                  op[0], op[1], op[2]);
9687                           printf ("  p = 0x%x,", p);
9688                           printf ("  sz = 0x%x,", sz);
9689                           printf ("  rdst = 0x%x,", rdst);
9690                           printf ("  rsrc = 0x%x\n", rsrc);
9691                         }
9692                       SYNTAX("mov%s     %1, %0");
9693 #line 324 "rx-decode.opc"
9694                       ID(mov); sBWL (sz); SR(rsrc); F("----");
9695                       OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
9696
9697                     }
9698                   break;
9699               }
9700             break;
9701           case 0x21:
9702               GETBYTE ();
9703               switch (op[2] & 0x00)
9704               {
9705                 case 0x00:
9706                   goto op_semantics_71;
9707                   break;
9708               }
9709             break;
9710           case 0x22:
9711               GETBYTE ();
9712               switch (op[2] & 0x00)
9713               {
9714                 case 0x00:
9715                   goto op_semantics_71;
9716                   break;
9717               }
9718             break;
9719           case 0x24:
9720               GETBYTE ();
9721               switch (op[2] & 0x00)
9722               {
9723                 case 0x00:
9724                   goto op_semantics_71;
9725                   break;
9726               }
9727             break;
9728           case 0x25:
9729               GETBYTE ();
9730               switch (op[2] & 0x00)
9731               {
9732                 case 0x00:
9733                   goto op_semantics_71;
9734                   break;
9735               }
9736             break;
9737           case 0x26:
9738               GETBYTE ();
9739               switch (op[2] & 0x00)
9740               {
9741                 case 0x00:
9742                   goto op_semantics_71;
9743                   break;
9744               }
9745             break;
9746           case 0x28:
9747               GETBYTE ();
9748               switch (op[2] & 0x00)
9749               {
9750                 case 0x00:
9751                   op_semantics_72:
9752                     {
9753                       /** 1111 1101 0010 1p sz rsrc rdst        mov%s   %1, %0 */
9754 #line 328 "rx-decode.opc"
9755                       int p AU = (op[1] >> 2) & 0x01;
9756 #line 328 "rx-decode.opc"
9757                       int sz AU = op[1] & 0x03;
9758 #line 328 "rx-decode.opc"
9759                       int rsrc AU = (op[2] >> 4) & 0x0f;
9760 #line 328 "rx-decode.opc"
9761                       int rdst AU = op[2] & 0x0f;
9762                       if (trace)
9763                         {
9764                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9765                                  "/** 1111 1101 0010 1p sz rsrc rdst    mov%s   %1, %0 */",
9766                                  op[0], op[1], op[2]);
9767                           printf ("  p = 0x%x,", p);
9768                           printf ("  sz = 0x%x,", sz);
9769                           printf ("  rsrc = 0x%x,", rsrc);
9770                           printf ("  rdst = 0x%x\n", rdst);
9771                         }
9772                       SYNTAX("mov%s     %1, %0");
9773 #line 328 "rx-decode.opc"
9774                       ID(mov); sBWL (sz); DR(rdst); F("----");
9775                       OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9776
9777                     }
9778                   break;
9779               }
9780             break;
9781           case 0x29:
9782               GETBYTE ();
9783               switch (op[2] & 0x00)
9784               {
9785                 case 0x00:
9786                   goto op_semantics_72;
9787                   break;
9788               }
9789             break;
9790           case 0x2a:
9791               GETBYTE ();
9792               switch (op[2] & 0x00)
9793               {
9794                 case 0x00:
9795                   goto op_semantics_72;
9796                   break;
9797               }
9798             break;
9799           case 0x2c:
9800               GETBYTE ();
9801               switch (op[2] & 0x00)
9802               {
9803                 case 0x00:
9804                   goto op_semantics_72;
9805                   break;
9806               }
9807             break;
9808           case 0x2d:
9809               GETBYTE ();
9810               switch (op[2] & 0x00)
9811               {
9812                 case 0x00:
9813                   goto op_semantics_72;
9814                   break;
9815               }
9816             break;
9817           case 0x2e:
9818               GETBYTE ();
9819               switch (op[2] & 0x00)
9820               {
9821                 case 0x00:
9822                   goto op_semantics_72;
9823                   break;
9824               }
9825             break;
9826           case 0x38:
9827               GETBYTE ();
9828               switch (op[2] & 0x00)
9829               {
9830                 case 0x00:
9831                   op_semantics_73:
9832                     {
9833                       /** 1111 1101 0011 1p sz rsrc rdst        movu%s  %1, %0 */
9834 #line 338 "rx-decode.opc"
9835                       int p AU = (op[1] >> 2) & 0x01;
9836 #line 338 "rx-decode.opc"
9837                       int sz AU = op[1] & 0x03;
9838 #line 338 "rx-decode.opc"
9839                       int rsrc AU = (op[2] >> 4) & 0x0f;
9840 #line 338 "rx-decode.opc"
9841                       int rdst AU = op[2] & 0x0f;
9842                       if (trace)
9843                         {
9844                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9845                                  "/** 1111 1101 0011 1p sz rsrc rdst    movu%s  %1, %0 */",
9846                                  op[0], op[1], op[2]);
9847                           printf ("  p = 0x%x,", p);
9848                           printf ("  sz = 0x%x,", sz);
9849                           printf ("  rsrc = 0x%x,", rsrc);
9850                           printf ("  rdst = 0x%x\n", rdst);
9851                         }
9852                       SYNTAX("movu%s    %1, %0");
9853 #line 338 "rx-decode.opc"
9854                       ID(mov); uBWL (sz); DR(rdst); F("----");
9855                        OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9856
9857                     /*----------------------------------------------------------------------*/
9858                     /* PUSH/POP                                                         */
9859
9860                     }
9861                   break;
9862               }
9863             break;
9864           case 0x39:
9865               GETBYTE ();
9866               switch (op[2] & 0x00)
9867               {
9868                 case 0x00:
9869                   goto op_semantics_73;
9870                   break;
9871               }
9872             break;
9873           case 0x3a:
9874               GETBYTE ();
9875               switch (op[2] & 0x00)
9876               {
9877                 case 0x00:
9878                   goto op_semantics_73;
9879                   break;
9880               }
9881             break;
9882           case 0x3c:
9883               GETBYTE ();
9884               switch (op[2] & 0x00)
9885               {
9886                 case 0x00:
9887                   goto op_semantics_73;
9888                   break;
9889               }
9890             break;
9891           case 0x3d:
9892               GETBYTE ();
9893               switch (op[2] & 0x00)
9894               {
9895                 case 0x00:
9896                   goto op_semantics_73;
9897                   break;
9898               }
9899             break;
9900           case 0x3e:
9901               GETBYTE ();
9902               switch (op[2] & 0x00)
9903               {
9904                 case 0x00:
9905                   goto op_semantics_73;
9906                   break;
9907               }
9908             break;
9909           case 0x60:
9910               GETBYTE ();
9911               switch (op[2] & 0x00)
9912               {
9913                 case 0x00:
9914                     {
9915                       /** 1111 1101 0110 0000 rsrc rdst shlr    %2, %0 */
9916 #line 663 "rx-decode.opc"
9917                       int rsrc AU = (op[2] >> 4) & 0x0f;
9918 #line 663 "rx-decode.opc"
9919                       int rdst AU = op[2] & 0x0f;
9920                       if (trace)
9921                         {
9922                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9923                                  "/** 1111 1101 0110 0000 rsrc rdst     shlr    %2, %0 */",
9924                                  op[0], op[1], op[2]);
9925                           printf ("  rsrc = 0x%x,", rsrc);
9926                           printf ("  rdst = 0x%x\n", rdst);
9927                         }
9928                       SYNTAX("shlr      %2, %0");
9929 #line 663 "rx-decode.opc"
9930                       ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F("-SZC");
9931
9932                     }
9933                   break;
9934               }
9935             break;
9936           case 0x61:
9937               GETBYTE ();
9938               switch (op[2] & 0x00)
9939               {
9940                 case 0x00:
9941                     {
9942                       /** 1111 1101 0110 0001 rsrc rdst shar    %2, %0 */
9943 #line 653 "rx-decode.opc"
9944                       int rsrc AU = (op[2] >> 4) & 0x0f;
9945 #line 653 "rx-decode.opc"
9946                       int rdst AU = op[2] & 0x0f;
9947                       if (trace)
9948                         {
9949                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9950                                  "/** 1111 1101 0110 0001 rsrc rdst     shar    %2, %0 */",
9951                                  op[0], op[1], op[2]);
9952                           printf ("  rsrc = 0x%x,", rsrc);
9953                           printf ("  rdst = 0x%x\n", rdst);
9954                         }
9955                       SYNTAX("shar      %2, %0");
9956 #line 653 "rx-decode.opc"
9957                       ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F("0SZC");
9958
9959                     }
9960                   break;
9961               }
9962             break;
9963           case 0x62:
9964               GETBYTE ();
9965               switch (op[2] & 0x00)
9966               {
9967                 case 0x00:
9968                     {
9969                       /** 1111 1101 0110 0010 rsrc rdst shll    %2, %0 */
9970 #line 643 "rx-decode.opc"
9971                       int rsrc AU = (op[2] >> 4) & 0x0f;
9972 #line 643 "rx-decode.opc"
9973                       int rdst AU = op[2] & 0x0f;
9974                       if (trace)
9975                         {
9976                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9977                                  "/** 1111 1101 0110 0010 rsrc rdst     shll    %2, %0 */",
9978                                  op[0], op[1], op[2]);
9979                           printf ("  rsrc = 0x%x,", rsrc);
9980                           printf ("  rdst = 0x%x\n", rdst);
9981                         }
9982                       SYNTAX("shll      %2, %0");
9983 #line 643 "rx-decode.opc"
9984                       ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F("OSZC");
9985
9986                     }
9987                   break;
9988               }
9989             break;
9990           case 0x64:
9991               GETBYTE ();
9992               switch (op[2] & 0x00)
9993               {
9994                 case 0x00:
9995                     {
9996                       /** 1111 1101 0110 0100 rsrc rdst rotr    %1, %0 */
9997 #line 687 "rx-decode.opc"
9998                       int rsrc AU = (op[2] >> 4) & 0x0f;
9999 #line 687 "rx-decode.opc"
10000                       int rdst AU = op[2] & 0x0f;
10001                       if (trace)
10002                         {
10003                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10004                                  "/** 1111 1101 0110 0100 rsrc rdst     rotr    %1, %0 */",
10005                                  op[0], op[1], op[2]);
10006                           printf ("  rsrc = 0x%x,", rsrc);
10007                           printf ("  rdst = 0x%x\n", rdst);
10008                         }
10009                       SYNTAX("rotr      %1, %0");
10010 #line 687 "rx-decode.opc"
10011                       ID(rotr); SR(rsrc); DR(rdst); F("-SZC");
10012
10013                     }
10014                   break;
10015               }
10016             break;
10017           case 0x65:
10018               GETBYTE ();
10019               switch (op[2] & 0x00)
10020               {
10021                 case 0x00:
10022                     {
10023                       /** 1111 1101 0110 0101 rsrc rdst revw    %1, %0 */
10024 #line 690 "rx-decode.opc"
10025                       int rsrc AU = (op[2] >> 4) & 0x0f;
10026 #line 690 "rx-decode.opc"
10027                       int rdst AU = op[2] & 0x0f;
10028                       if (trace)
10029                         {
10030                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10031                                  "/** 1111 1101 0110 0101 rsrc rdst     revw    %1, %0 */",
10032                                  op[0], op[1], op[2]);
10033                           printf ("  rsrc = 0x%x,", rsrc);
10034                           printf ("  rdst = 0x%x\n", rdst);
10035                         }
10036                       SYNTAX("revw      %1, %0");
10037 #line 690 "rx-decode.opc"
10038                       ID(revw); SR(rsrc); DR(rdst);
10039
10040                     }
10041                   break;
10042               }
10043             break;
10044           case 0x66:
10045               GETBYTE ();
10046               switch (op[2] & 0x00)
10047               {
10048                 case 0x00:
10049                     {
10050                       /** 1111 1101 0110 0110 rsrc rdst rotl    %1, %0 */
10051 #line 681 "rx-decode.opc"
10052                       int rsrc AU = (op[2] >> 4) & 0x0f;
10053 #line 681 "rx-decode.opc"
10054                       int rdst AU = op[2] & 0x0f;
10055                       if (trace)
10056                         {
10057                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10058                                  "/** 1111 1101 0110 0110 rsrc rdst     rotl    %1, %0 */",
10059                                  op[0], op[1], op[2]);
10060                           printf ("  rsrc = 0x%x,", rsrc);
10061                           printf ("  rdst = 0x%x\n", rdst);
10062                         }
10063                       SYNTAX("rotl      %1, %0");
10064 #line 681 "rx-decode.opc"
10065                       ID(rotl); SR(rsrc); DR(rdst); F("-SZC");
10066
10067                     }
10068                   break;
10069               }
10070             break;
10071           case 0x67:
10072               GETBYTE ();
10073               switch (op[2] & 0x00)
10074               {
10075                 case 0x00:
10076                     {
10077                       /** 1111 1101 0110 0111 rsrc rdst revl    %1, %0 */
10078 #line 693 "rx-decode.opc"
10079                       int rsrc AU = (op[2] >> 4) & 0x0f;
10080 #line 693 "rx-decode.opc"
10081                       int rdst AU = op[2] & 0x0f;
10082                       if (trace)
10083                         {
10084                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10085                                  "/** 1111 1101 0110 0111 rsrc rdst     revl    %1, %0 */",
10086                                  op[0], op[1], op[2]);
10087                           printf ("  rsrc = 0x%x,", rsrc);
10088                           printf ("  rdst = 0x%x\n", rdst);
10089                         }
10090                       SYNTAX("revl      %1, %0");
10091 #line 693 "rx-decode.opc"
10092                       ID(revl); SR(rsrc); DR(rdst);
10093
10094                     /*----------------------------------------------------------------------*/
10095                     /* BRANCH                                                           */
10096
10097                     }
10098                   break;
10099               }
10100             break;
10101           case 0x68:
10102               GETBYTE ();
10103               switch (op[2] & 0x00)
10104               {
10105                 case 0x00:
10106                   op_semantics_74:
10107                     {
10108                       /** 1111 1101 0110 100c rsrc rdst mvtc    %1, %0 */
10109 #line 936 "rx-decode.opc"
10110                       int c AU = op[1] & 0x01;
10111 #line 936 "rx-decode.opc"
10112                       int rsrc AU = (op[2] >> 4) & 0x0f;
10113 #line 936 "rx-decode.opc"
10114                       int rdst AU = op[2] & 0x0f;
10115                       if (trace)
10116                         {
10117                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10118                                  "/** 1111 1101 0110 100c rsrc rdst     mvtc    %1, %0 */",
10119                                  op[0], op[1], op[2]);
10120                           printf ("  c = 0x%x,", c);
10121                           printf ("  rsrc = 0x%x,", rsrc);
10122                           printf ("  rdst = 0x%x\n", rdst);
10123                         }
10124                       SYNTAX("mvtc      %1, %0");
10125 #line 936 "rx-decode.opc"
10126                       ID(mov); SR(rsrc); DR(c*16+rdst + 16);
10127
10128                     }
10129                   break;
10130               }
10131             break;
10132           case 0x69:
10133               GETBYTE ();
10134               switch (op[2] & 0x00)
10135               {
10136                 case 0x00:
10137                   goto op_semantics_74;
10138                   break;
10139               }
10140             break;
10141           case 0x6a:
10142               GETBYTE ();
10143               switch (op[2] & 0x00)
10144               {
10145                 case 0x00:
10146                   op_semantics_75:
10147                     {
10148                       /** 1111 1101 0110 101s rsrc rdst mvfc    %1, %0 */
10149 #line 939 "rx-decode.opc"
10150                       int s AU = op[1] & 0x01;
10151 #line 939 "rx-decode.opc"
10152                       int rsrc AU = (op[2] >> 4) & 0x0f;
10153 #line 939 "rx-decode.opc"
10154                       int rdst AU = op[2] & 0x0f;
10155                       if (trace)
10156                         {
10157                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10158                                  "/** 1111 1101 0110 101s rsrc rdst     mvfc    %1, %0 */",
10159                                  op[0], op[1], op[2]);
10160                           printf ("  s = 0x%x,", s);
10161                           printf ("  rsrc = 0x%x,", rsrc);
10162                           printf ("  rdst = 0x%x\n", rdst);
10163                         }
10164                       SYNTAX("mvfc      %1, %0");
10165 #line 939 "rx-decode.opc"
10166                       ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
10167
10168                     /*----------------------------------------------------------------------*/
10169                     /* INTERRUPTS                                                               */
10170
10171                     }
10172                   break;
10173               }
10174             break;
10175           case 0x6b:
10176               GETBYTE ();
10177               switch (op[2] & 0x00)
10178               {
10179                 case 0x00:
10180                   goto op_semantics_75;
10181                   break;
10182               }
10183             break;
10184           case 0x6c:
10185               GETBYTE ();
10186               switch (op[2] & 0x00)
10187               {
10188                 case 0x00:
10189                   op_semantics_76:
10190                     {
10191                       /** 1111 1101 0110 110i mmmm rdst rotr    #%1, %0 */
10192 #line 684 "rx-decode.opc"
10193                       int i AU = op[1] & 0x01;
10194 #line 684 "rx-decode.opc"
10195                       int mmmm AU = (op[2] >> 4) & 0x0f;
10196 #line 684 "rx-decode.opc"
10197                       int rdst AU = op[2] & 0x0f;
10198                       if (trace)
10199                         {
10200                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10201                                  "/** 1111 1101 0110 110i mmmm rdst     rotr    #%1, %0 */",
10202                                  op[0], op[1], op[2]);
10203                           printf ("  i = 0x%x,", i);
10204                           printf ("  mmmm = 0x%x,", mmmm);
10205                           printf ("  rdst = 0x%x\n", rdst);
10206                         }
10207                       SYNTAX("rotr      #%1, %0");
10208 #line 684 "rx-decode.opc"
10209                       ID(rotr); SC(i*16+mmmm); DR(rdst); F("-SZC");
10210
10211                     }
10212                   break;
10213               }
10214             break;
10215           case 0x6d:
10216               GETBYTE ();
10217               switch (op[2] & 0x00)
10218               {
10219                 case 0x00:
10220                   goto op_semantics_76;
10221                   break;
10222               }
10223             break;
10224           case 0x6e:
10225               GETBYTE ();
10226               switch (op[2] & 0x00)
10227               {
10228                 case 0x00:
10229                   op_semantics_77:
10230                     {
10231                       /** 1111 1101 0110 111i mmmm rdst rotl    #%1, %0 */
10232 #line 678 "rx-decode.opc"
10233                       int i AU = op[1] & 0x01;
10234 #line 678 "rx-decode.opc"
10235                       int mmmm AU = (op[2] >> 4) & 0x0f;
10236 #line 678 "rx-decode.opc"
10237                       int rdst AU = op[2] & 0x0f;
10238                       if (trace)
10239                         {
10240                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10241                                  "/** 1111 1101 0110 111i mmmm rdst     rotl    #%1, %0 */",
10242                                  op[0], op[1], op[2]);
10243                           printf ("  i = 0x%x,", i);
10244                           printf ("  mmmm = 0x%x,", mmmm);
10245                           printf ("  rdst = 0x%x\n", rdst);
10246                         }
10247                       SYNTAX("rotl      #%1, %0");
10248 #line 678 "rx-decode.opc"
10249                       ID(rotl); SC(i*16+mmmm); DR(rdst); F("-SZC");
10250
10251                     }
10252                   break;
10253               }
10254             break;
10255           case 0x6f:
10256               GETBYTE ();
10257               switch (op[2] & 0x00)
10258               {
10259                 case 0x00:
10260                   goto op_semantics_77;
10261                   break;
10262               }
10263             break;
10264           case 0x70:
10265               GETBYTE ();
10266               switch (op[2] & 0xf0)
10267               {
10268                 case 0x20:
10269                   op_semantics_78:
10270                     {
10271                       /** 1111 1101 0111 im00 0010rdst  adc     #%1, %0 */
10272 #line 468 "rx-decode.opc"
10273                       int im AU = (op[1] >> 2) & 0x03;
10274 #line 468 "rx-decode.opc"
10275                       int rdst AU = op[2] & 0x0f;
10276                       if (trace)
10277                         {
10278                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10279                                  "/** 1111 1101 0111 im00 0010rdst      adc     #%1, %0 */",
10280                                  op[0], op[1], op[2]);
10281                           printf ("  im = 0x%x,", im);
10282                           printf ("  rdst = 0x%x\n", rdst);
10283                         }
10284                       SYNTAX("adc       #%1, %0");
10285 #line 468 "rx-decode.opc"
10286                       ID(adc); SC(IMMex(im)); DR(rdst); F("OSZC");
10287
10288                     }
10289                   break;
10290                 case 0x40:
10291                   op_semantics_79:
10292                     {
10293                       /** 1111 1101 0111 im00 0100rdst  max     #%1, %0 */
10294 #line 550 "rx-decode.opc"
10295                       int im AU = (op[1] >> 2) & 0x03;
10296 #line 550 "rx-decode.opc"
10297                       int rdst AU = op[2] & 0x0f;
10298                       if (trace)
10299                         {
10300                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10301                                  "/** 1111 1101 0111 im00 0100rdst      max     #%1, %0 */",
10302                                  op[0], op[1], op[2]);
10303                           printf ("  im = 0x%x,", im);
10304                           printf ("  rdst = 0x%x\n", rdst);
10305                         }
10306                       SYNTAX("max       #%1, %0");
10307 #line 550 "rx-decode.opc"
10308                       ID(max); DR(rdst); SC(IMMex(im));
10309
10310                     }
10311                   break;
10312                 case 0x50:
10313                   op_semantics_80:
10314                     {
10315                       /** 1111 1101 0111 im00 0101rdst  min     #%1, %0 */
10316 #line 562 "rx-decode.opc"
10317                       int im AU = (op[1] >> 2) & 0x03;
10318 #line 562 "rx-decode.opc"
10319                       int rdst AU = op[2] & 0x0f;
10320                       if (trace)
10321                         {
10322                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10323                                  "/** 1111 1101 0111 im00 0101rdst      min     #%1, %0 */",
10324                                  op[0], op[1], op[2]);
10325                           printf ("  im = 0x%x,", im);
10326                           printf ("  rdst = 0x%x\n", rdst);
10327                         }
10328                       SYNTAX("min       #%1, %0");
10329 #line 562 "rx-decode.opc"
10330                       ID(min); DR(rdst); SC(IMMex(im));
10331
10332                     }
10333                   break;
10334                 case 0x60:
10335                   op_semantics_81:
10336                     {
10337                       /** 1111 1101 0111 im00 0110rdst  emul    #%1, %0 */
10338 #line 592 "rx-decode.opc"
10339                       int im AU = (op[1] >> 2) & 0x03;
10340 #line 592 "rx-decode.opc"
10341                       int rdst AU = op[2] & 0x0f;
10342                       if (trace)
10343                         {
10344                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10345                                  "/** 1111 1101 0111 im00 0110rdst      emul    #%1, %0 */",
10346                                  op[0], op[1], op[2]);
10347                           printf ("  im = 0x%x,", im);
10348                           printf ("  rdst = 0x%x\n", rdst);
10349                         }
10350                       SYNTAX("emul      #%1, %0");
10351 #line 592 "rx-decode.opc"
10352                       ID(emul); DR(rdst); SC(IMMex(im));
10353
10354                     }
10355                   break;
10356                 case 0x70:
10357                   op_semantics_82:
10358                     {
10359                       /** 1111 1101 0111 im00 0111rdst  emulu   #%1, %0 */
10360 #line 604 "rx-decode.opc"
10361                       int im AU = (op[1] >> 2) & 0x03;
10362 #line 604 "rx-decode.opc"
10363                       int rdst AU = op[2] & 0x0f;
10364                       if (trace)
10365                         {
10366                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10367                                  "/** 1111 1101 0111 im00 0111rdst      emulu   #%1, %0 */",
10368                                  op[0], op[1], op[2]);
10369                           printf ("  im = 0x%x,", im);
10370                           printf ("  rdst = 0x%x\n", rdst);
10371                         }
10372                       SYNTAX("emulu     #%1, %0");
10373 #line 604 "rx-decode.opc"
10374                       ID(emulu); DR(rdst); SC(IMMex(im));
10375
10376                     }
10377                   break;
10378                 case 0x80:
10379                   op_semantics_83:
10380                     {
10381                       /** 1111 1101 0111 im00 1000rdst  div     #%1, %0 */
10382 #line 616 "rx-decode.opc"
10383                       int im AU = (op[1] >> 2) & 0x03;
10384 #line 616 "rx-decode.opc"
10385                       int rdst AU = op[2] & 0x0f;
10386                       if (trace)
10387                         {
10388                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10389                                  "/** 1111 1101 0111 im00 1000rdst      div     #%1, %0 */",
10390                                  op[0], op[1], op[2]);
10391                           printf ("  im = 0x%x,", im);
10392                           printf ("  rdst = 0x%x\n", rdst);
10393                         }
10394                       SYNTAX("div       #%1, %0");
10395 #line 616 "rx-decode.opc"
10396                       ID(div); DR(rdst); SC(IMMex(im)); F("O---");
10397
10398                     }
10399                   break;
10400                 case 0x90:
10401                   op_semantics_84:
10402                     {
10403                       /** 1111 1101 0111 im00 1001rdst  divu    #%1, %0 */
10404 #line 628 "rx-decode.opc"
10405                       int im AU = (op[1] >> 2) & 0x03;
10406 #line 628 "rx-decode.opc"
10407                       int rdst AU = op[2] & 0x0f;
10408                       if (trace)
10409                         {
10410                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10411                                  "/** 1111 1101 0111 im00 1001rdst      divu    #%1, %0 */",
10412                                  op[0], op[1], op[2]);
10413                           printf ("  im = 0x%x,", im);
10414                           printf ("  rdst = 0x%x\n", rdst);
10415                         }
10416                       SYNTAX("divu      #%1, %0");
10417 #line 628 "rx-decode.opc"
10418                       ID(divu); DR(rdst); SC(IMMex(im)); F("O---");
10419
10420                     }
10421                   break;
10422                 case 0xc0:
10423                   op_semantics_85:
10424                     {
10425                       /** 1111 1101 0111 im00 1100rdst  tst     #%1, %2 */
10426 #line 447 "rx-decode.opc"
10427                       int im AU = (op[1] >> 2) & 0x03;
10428 #line 447 "rx-decode.opc"
10429                       int rdst AU = op[2] & 0x0f;
10430                       if (trace)
10431                         {
10432                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10433                                  "/** 1111 1101 0111 im00 1100rdst      tst     #%1, %2 */",
10434                                  op[0], op[1], op[2]);
10435                           printf ("  im = 0x%x,", im);
10436                           printf ("  rdst = 0x%x\n", rdst);
10437                         }
10438                       SYNTAX("tst       #%1, %2");
10439 #line 447 "rx-decode.opc"
10440                       ID(and); SC(IMMex(im)); S2R(rdst); F("-SZ-");
10441
10442                     }
10443                   break;
10444                 case 0xd0:
10445                   op_semantics_86:
10446                     {
10447                       /** 1111 1101 0111 im00 1101rdst  xor     #%1, %0 */
10448 #line 426 "rx-decode.opc"
10449                       int im AU = (op[1] >> 2) & 0x03;
10450 #line 426 "rx-decode.opc"
10451                       int rdst AU = op[2] & 0x0f;
10452                       if (trace)
10453                         {
10454                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10455                                  "/** 1111 1101 0111 im00 1101rdst      xor     #%1, %0 */",
10456                                  op[0], op[1], op[2]);
10457                           printf ("  im = 0x%x,", im);
10458                           printf ("  rdst = 0x%x\n", rdst);
10459                         }
10460                       SYNTAX("xor       #%1, %0");
10461 #line 426 "rx-decode.opc"
10462                       ID(xor); SC(IMMex(im)); DR(rdst); F("-SZ-");
10463
10464                     }
10465                   break;
10466                 case 0xe0:
10467                   op_semantics_87:
10468                     {
10469                       /** 1111 1101 0111 im00 1110rdst  stz     #%1, %0 */
10470 #line 372 "rx-decode.opc"
10471                       int im AU = (op[1] >> 2) & 0x03;
10472 #line 372 "rx-decode.opc"
10473                       int rdst AU = op[2] & 0x0f;
10474                       if (trace)
10475                         {
10476                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10477                                  "/** 1111 1101 0111 im00 1110rdst      stz     #%1, %0 */",
10478                                  op[0], op[1], op[2]);
10479                           printf ("  im = 0x%x,", im);
10480                           printf ("  rdst = 0x%x\n", rdst);
10481                         }
10482                       SYNTAX("stz       #%1, %0");
10483 #line 372 "rx-decode.opc"
10484                       ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
10485
10486                     }
10487                   break;
10488                 case 0xf0:
10489                   op_semantics_88:
10490                     {
10491                       /** 1111 1101 0111 im00 1111rdst  stnz    #%1, %0 */
10492 #line 375 "rx-decode.opc"
10493                       int im AU = (op[1] >> 2) & 0x03;
10494 #line 375 "rx-decode.opc"
10495                       int rdst AU = op[2] & 0x0f;
10496                       if (trace)
10497                         {
10498                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10499                                  "/** 1111 1101 0111 im00 1111rdst      stnz    #%1, %0 */",
10500                                  op[0], op[1], op[2]);
10501                           printf ("  im = 0x%x,", im);
10502                           printf ("  rdst = 0x%x\n", rdst);
10503                         }
10504                       SYNTAX("stnz      #%1, %0");
10505 #line 375 "rx-decode.opc"
10506                       ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
10507
10508                     /*----------------------------------------------------------------------*/
10509                     /* RTSD                                                                     */
10510
10511                     }
10512                   break;
10513                 default: UNSUPPORTED(); break;
10514               }
10515             break;
10516           case 0x72:
10517               GETBYTE ();
10518               switch (op[2] & 0xf0)
10519               {
10520                 case 0x00:
10521                     {
10522                       /** 1111 1101 0111 0010 0000 rdst fsub    #%1, %0 */
10523 #line 836 "rx-decode.opc"
10524                       int rdst AU = op[2] & 0x0f;
10525                       if (trace)
10526                         {
10527                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10528                                  "/** 1111 1101 0111 0010 0000 rdst     fsub    #%1, %0 */",
10529                                  op[0], op[1], op[2]);
10530                           printf ("  rdst = 0x%x\n", rdst);
10531                         }
10532                       SYNTAX("fsub      #%1, %0");
10533 #line 836 "rx-decode.opc"
10534                       ID(fsub); DR(rdst); SC(IMM(0)); F("-SZ-");
10535
10536                     }
10537                   break;
10538                 case 0x10:
10539                     {
10540                       /** 1111 1101 0111 0010 0001 rdst fcmp    #%1, %0 */
10541 #line 830 "rx-decode.opc"
10542                       int rdst AU = op[2] & 0x0f;
10543                       if (trace)
10544                         {
10545                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10546                                  "/** 1111 1101 0111 0010 0001 rdst     fcmp    #%1, %0 */",
10547                                  op[0], op[1], op[2]);
10548                           printf ("  rdst = 0x%x\n", rdst);
10549                         }
10550                       SYNTAX("fcmp      #%1, %0");
10551 #line 830 "rx-decode.opc"
10552                       ID(fcmp); DR(rdst); SC(IMM(0)); F("OSZ-");
10553
10554                     }
10555                   break;
10556                 case 0x20:
10557                     {
10558                       /** 1111 1101 0111 0010 0010 rdst fadd    #%1, %0 */
10559 #line 824 "rx-decode.opc"
10560                       int rdst AU = op[2] & 0x0f;
10561                       if (trace)
10562                         {
10563                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10564                                  "/** 1111 1101 0111 0010 0010 rdst     fadd    #%1, %0 */",
10565                                  op[0], op[1], op[2]);
10566                           printf ("  rdst = 0x%x\n", rdst);
10567                         }
10568                       SYNTAX("fadd      #%1, %0");
10569 #line 824 "rx-decode.opc"
10570                       ID(fadd); DR(rdst); SC(IMM(0)); F("-SZ-");
10571
10572                     }
10573                   break;
10574                 case 0x30:
10575                     {
10576                       /** 1111 1101 0111 0010 0011 rdst fmul    #%1, %0 */
10577 #line 845 "rx-decode.opc"
10578                       int rdst AU = op[2] & 0x0f;
10579                       if (trace)
10580                         {
10581                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10582                                  "/** 1111 1101 0111 0010 0011 rdst     fmul    #%1, %0 */",
10583                                  op[0], op[1], op[2]);
10584                           printf ("  rdst = 0x%x\n", rdst);
10585                         }
10586                       SYNTAX("fmul      #%1, %0");
10587 #line 845 "rx-decode.opc"
10588                       ID(fmul); DR(rdst); SC(IMM(0)); F("-SZ-");
10589
10590                     }
10591                   break;
10592                 case 0x40:
10593                     {
10594                       /** 1111 1101 0111 0010 0100 rdst fdiv    #%1, %0 */
10595 #line 851 "rx-decode.opc"
10596                       int rdst AU = op[2] & 0x0f;
10597                       if (trace)
10598                         {
10599                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10600                                  "/** 1111 1101 0111 0010 0100 rdst     fdiv    #%1, %0 */",
10601                                  op[0], op[1], op[2]);
10602                           printf ("  rdst = 0x%x\n", rdst);
10603                         }
10604                       SYNTAX("fdiv      #%1, %0");
10605 #line 851 "rx-decode.opc"
10606                       ID(fdiv); DR(rdst); SC(IMM(0)); F("-SZ-");
10607
10608                     }
10609                   break;
10610                 default: UNSUPPORTED(); break;
10611               }
10612             break;
10613           case 0x73:
10614               GETBYTE ();
10615               switch (op[2] & 0xe0)
10616               {
10617                 case 0x00:
10618                   op_semantics_89:
10619                     {
10620                       /** 1111 1101 0111 im11 000crdst  mvtc    #%1, %0 */
10621 #line 933 "rx-decode.opc"
10622                       int im AU = (op[1] >> 2) & 0x03;
10623 #line 933 "rx-decode.opc"
10624                       int crdst AU = op[2] & 0x1f;
10625                       if (trace)
10626                         {
10627                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10628                                  "/** 1111 1101 0111 im11 000crdst      mvtc    #%1, %0 */",
10629                                  op[0], op[1], op[2]);
10630                           printf ("  im = 0x%x,", im);
10631                           printf ("  crdst = 0x%x\n", crdst);
10632                         }
10633                       SYNTAX("mvtc      #%1, %0");
10634 #line 933 "rx-decode.opc"
10635                       ID(mov); SC(IMMex(im)); DR(crdst + 16);
10636
10637                     }
10638                   break;
10639                 default: UNSUPPORTED(); break;
10640               }
10641             break;
10642           case 0x74:
10643               GETBYTE ();
10644               switch (op[2] & 0xf0)
10645               {
10646                 case 0x20:
10647                   goto op_semantics_78;
10648                   break;
10649                 case 0x40:
10650                   goto op_semantics_79;
10651                   break;
10652                 case 0x50:
10653                   goto op_semantics_80;
10654                   break;
10655                 case 0x60:
10656                   goto op_semantics_81;
10657                   break;
10658                 case 0x70:
10659                   goto op_semantics_82;
10660                   break;
10661                 case 0x80:
10662                   goto op_semantics_83;
10663                   break;
10664                 case 0x90:
10665                   goto op_semantics_84;
10666                   break;
10667                 case 0xc0:
10668                   goto op_semantics_85;
10669                   break;
10670                 case 0xd0:
10671                   goto op_semantics_86;
10672                   break;
10673                 case 0xe0:
10674                   goto op_semantics_87;
10675                   break;
10676                 case 0xf0:
10677                   goto op_semantics_88;
10678                   break;
10679                 default: UNSUPPORTED(); break;
10680               }
10681             break;
10682           case 0x77:
10683               GETBYTE ();
10684               switch (op[2] & 0xe0)
10685               {
10686                 case 0x00:
10687                   goto op_semantics_89;
10688                   break;
10689                 default: UNSUPPORTED(); break;
10690               }
10691             break;
10692           case 0x78:
10693               GETBYTE ();
10694               switch (op[2] & 0xf0)
10695               {
10696                 case 0x20:
10697                   goto op_semantics_78;
10698                   break;
10699                 case 0x40:
10700                   goto op_semantics_79;
10701                   break;
10702                 case 0x50:
10703                   goto op_semantics_80;
10704                   break;
10705                 case 0x60:
10706                   goto op_semantics_81;
10707                   break;
10708                 case 0x70:
10709                   goto op_semantics_82;
10710                   break;
10711                 case 0x80:
10712                   goto op_semantics_83;
10713                   break;
10714                 case 0x90:
10715                   goto op_semantics_84;
10716                   break;
10717                 case 0xc0:
10718                   goto op_semantics_85;
10719                   break;
10720                 case 0xd0:
10721                   goto op_semantics_86;
10722                   break;
10723                 case 0xe0:
10724                   goto op_semantics_87;
10725                   break;
10726                 case 0xf0:
10727                   goto op_semantics_88;
10728                   break;
10729                 default: UNSUPPORTED(); break;
10730               }
10731             break;
10732           case 0x7b:
10733               GETBYTE ();
10734               switch (op[2] & 0xe0)
10735               {
10736                 case 0x00:
10737                   goto op_semantics_89;
10738                   break;
10739                 default: UNSUPPORTED(); break;
10740               }
10741             break;
10742           case 0x7c:
10743               GETBYTE ();
10744               switch (op[2] & 0xf0)
10745               {
10746                 case 0x20:
10747                   goto op_semantics_78;
10748                   break;
10749                 case 0x40:
10750                   goto op_semantics_79;
10751                   break;
10752                 case 0x50:
10753                   goto op_semantics_80;
10754                   break;
10755                 case 0x60:
10756                   goto op_semantics_81;
10757                   break;
10758                 case 0x70:
10759                   goto op_semantics_82;
10760                   break;
10761                 case 0x80:
10762                   goto op_semantics_83;
10763                   break;
10764                 case 0x90:
10765                   goto op_semantics_84;
10766                   break;
10767                 case 0xc0:
10768                   goto op_semantics_85;
10769                   break;
10770                 case 0xd0:
10771                   goto op_semantics_86;
10772                   break;
10773                 case 0xe0:
10774                   goto op_semantics_87;
10775                   break;
10776                 case 0xf0:
10777                   goto op_semantics_88;
10778                   break;
10779                 default: UNSUPPORTED(); break;
10780               }
10781             break;
10782           case 0x7f:
10783               GETBYTE ();
10784               switch (op[2] & 0xe0)
10785               {
10786                 case 0x00:
10787                   goto op_semantics_89;
10788                   break;
10789                 default: UNSUPPORTED(); break;
10790               }
10791             break;
10792           case 0x80:
10793               GETBYTE ();
10794               switch (op[2] & 0x00)
10795               {
10796                 case 0x00:
10797                   op_semantics_90:
10798                     {
10799                       /** 1111 1101 100immmm rsrc rdst  shlr    #%2, %1, %0 */
10800 #line 666 "rx-decode.opc"
10801                       int immmm AU = op[1] & 0x1f;
10802 #line 666 "rx-decode.opc"
10803                       int rsrc AU = (op[2] >> 4) & 0x0f;
10804 #line 666 "rx-decode.opc"
10805                       int rdst AU = op[2] & 0x0f;
10806                       if (trace)
10807                         {
10808                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10809                                  "/** 1111 1101 100immmm rsrc rdst      shlr    #%2, %1, %0 */",
10810                                  op[0], op[1], op[2]);
10811                           printf ("  immmm = 0x%x,", immmm);
10812                           printf ("  rsrc = 0x%x,", rsrc);
10813                           printf ("  rdst = 0x%x\n", rdst);
10814                         }
10815                       SYNTAX("shlr      #%2, %1, %0");
10816 #line 666 "rx-decode.opc"
10817                       ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F("-SZC");
10818
10819                     /*----------------------------------------------------------------------*/
10820                     /* ROTATE                                                           */
10821
10822                     }
10823                   break;
10824               }
10825             break;
10826           case 0x81:
10827               GETBYTE ();
10828               switch (op[2] & 0x00)
10829               {
10830                 case 0x00:
10831                   goto op_semantics_90;
10832                   break;
10833               }
10834             break;
10835           case 0x82:
10836               GETBYTE ();
10837               switch (op[2] & 0x00)
10838               {
10839                 case 0x00:
10840                   goto op_semantics_90;
10841                   break;
10842               }
10843             break;
10844           case 0x83:
10845               GETBYTE ();
10846               switch (op[2] & 0x00)
10847               {
10848                 case 0x00:
10849                   goto op_semantics_90;
10850                   break;
10851               }
10852             break;
10853           case 0x84:
10854               GETBYTE ();
10855               switch (op[2] & 0x00)
10856               {
10857                 case 0x00:
10858                   goto op_semantics_90;
10859                   break;
10860               }
10861             break;
10862           case 0x85:
10863               GETBYTE ();
10864               switch (op[2] & 0x00)
10865               {
10866                 case 0x00:
10867                   goto op_semantics_90;
10868                   break;
10869               }
10870             break;
10871           case 0x86:
10872               GETBYTE ();
10873               switch (op[2] & 0x00)
10874               {
10875                 case 0x00:
10876                   goto op_semantics_90;
10877                   break;
10878               }
10879             break;
10880           case 0x87:
10881               GETBYTE ();
10882               switch (op[2] & 0x00)
10883               {
10884                 case 0x00:
10885                   goto op_semantics_90;
10886                   break;
10887               }
10888             break;
10889           case 0x88:
10890               GETBYTE ();
10891               switch (op[2] & 0x00)
10892               {
10893                 case 0x00:
10894                   goto op_semantics_90;
10895                   break;
10896               }
10897             break;
10898           case 0x89:
10899               GETBYTE ();
10900               switch (op[2] & 0x00)
10901               {
10902                 case 0x00:
10903                   goto op_semantics_90;
10904                   break;
10905               }
10906             break;
10907           case 0x8a:
10908               GETBYTE ();
10909               switch (op[2] & 0x00)
10910               {
10911                 case 0x00:
10912                   goto op_semantics_90;
10913                   break;
10914               }
10915             break;
10916           case 0x8b:
10917               GETBYTE ();
10918               switch (op[2] & 0x00)
10919               {
10920                 case 0x00:
10921                   goto op_semantics_90;
10922                   break;
10923               }
10924             break;
10925           case 0x8c:
10926               GETBYTE ();
10927               switch (op[2] & 0x00)
10928               {
10929                 case 0x00:
10930                   goto op_semantics_90;
10931                   break;
10932               }
10933             break;
10934           case 0x8d:
10935               GETBYTE ();
10936               switch (op[2] & 0x00)
10937               {
10938                 case 0x00:
10939                   goto op_semantics_90;
10940                   break;
10941               }
10942             break;
10943           case 0x8e:
10944               GETBYTE ();
10945               switch (op[2] & 0x00)
10946               {
10947                 case 0x00:
10948                   goto op_semantics_90;
10949                   break;
10950               }
10951             break;
10952           case 0x8f:
10953               GETBYTE ();
10954               switch (op[2] & 0x00)
10955               {
10956                 case 0x00:
10957                   goto op_semantics_90;
10958                   break;
10959               }
10960             break;
10961           case 0x90:
10962               GETBYTE ();
10963               switch (op[2] & 0x00)
10964               {
10965                 case 0x00:
10966                   goto op_semantics_90;
10967                   break;
10968               }
10969             break;
10970           case 0x91:
10971               GETBYTE ();
10972               switch (op[2] & 0x00)
10973               {
10974                 case 0x00:
10975                   goto op_semantics_90;
10976                   break;
10977               }
10978             break;
10979           case 0x92:
10980               GETBYTE ();
10981               switch (op[2] & 0x00)
10982               {
10983                 case 0x00:
10984                   goto op_semantics_90;
10985                   break;
10986               }
10987             break;
10988           case 0x93:
10989               GETBYTE ();
10990               switch (op[2] & 0x00)
10991               {
10992                 case 0x00:
10993                   goto op_semantics_90;
10994                   break;
10995               }
10996             break;
10997           case 0x94:
10998               GETBYTE ();
10999               switch (op[2] & 0x00)
11000               {
11001                 case 0x00:
11002                   goto op_semantics_90;
11003                   break;
11004               }
11005             break;
11006           case 0x95:
11007               GETBYTE ();
11008               switch (op[2] & 0x00)
11009               {
11010                 case 0x00:
11011                   goto op_semantics_90;
11012                   break;
11013               }
11014             break;
11015           case 0x96:
11016               GETBYTE ();
11017               switch (op[2] & 0x00)
11018               {
11019                 case 0x00:
11020                   goto op_semantics_90;
11021                   break;
11022               }
11023             break;
11024           case 0x97:
11025               GETBYTE ();
11026               switch (op[2] & 0x00)
11027               {
11028                 case 0x00:
11029                   goto op_semantics_90;
11030                   break;
11031               }
11032             break;
11033           case 0x98:
11034               GETBYTE ();
11035               switch (op[2] & 0x00)
11036               {
11037                 case 0x00:
11038                   goto op_semantics_90;
11039                   break;
11040               }
11041             break;
11042           case 0x99:
11043               GETBYTE ();
11044               switch (op[2] & 0x00)
11045               {
11046                 case 0x00:
11047                   goto op_semantics_90;
11048                   break;
11049               }
11050             break;
11051           case 0x9a:
11052               GETBYTE ();
11053               switch (op[2] & 0x00)
11054               {
11055                 case 0x00:
11056                   goto op_semantics_90;
11057                   break;
11058               }
11059             break;
11060           case 0x9b:
11061               GETBYTE ();
11062               switch (op[2] & 0x00)
11063               {
11064                 case 0x00:
11065                   goto op_semantics_90;
11066                   break;
11067               }
11068             break;
11069           case 0x9c:
11070               GETBYTE ();
11071               switch (op[2] & 0x00)
11072               {
11073                 case 0x00:
11074                   goto op_semantics_90;
11075                   break;
11076               }
11077             break;
11078           case 0x9d:
11079               GETBYTE ();
11080               switch (op[2] & 0x00)
11081               {
11082                 case 0x00:
11083                   goto op_semantics_90;
11084                   break;
11085               }
11086             break;
11087           case 0x9e:
11088               GETBYTE ();
11089               switch (op[2] & 0x00)
11090               {
11091                 case 0x00:
11092                   goto op_semantics_90;
11093                   break;
11094               }
11095             break;
11096           case 0x9f:
11097               GETBYTE ();
11098               switch (op[2] & 0x00)
11099               {
11100                 case 0x00:
11101                   goto op_semantics_90;
11102                   break;
11103               }
11104             break;
11105           case 0xa0:
11106               GETBYTE ();
11107               switch (op[2] & 0x00)
11108               {
11109                 case 0x00:
11110                   op_semantics_91:
11111                     {
11112                       /** 1111 1101 101immmm rsrc rdst  shar    #%2, %1, %0 */
11113 #line 656 "rx-decode.opc"
11114                       int immmm AU = op[1] & 0x1f;
11115 #line 656 "rx-decode.opc"
11116                       int rsrc AU = (op[2] >> 4) & 0x0f;
11117 #line 656 "rx-decode.opc"
11118                       int rdst AU = op[2] & 0x0f;
11119                       if (trace)
11120                         {
11121                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11122                                  "/** 1111 1101 101immmm rsrc rdst      shar    #%2, %1, %0 */",
11123                                  op[0], op[1], op[2]);
11124                           printf ("  immmm = 0x%x,", immmm);
11125                           printf ("  rsrc = 0x%x,", rsrc);
11126                           printf ("  rdst = 0x%x\n", rdst);
11127                         }
11128                       SYNTAX("shar      #%2, %1, %0");
11129 #line 656 "rx-decode.opc"
11130                       ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F("0SZC");
11131
11132
11133                     }
11134                   break;
11135               }
11136             break;
11137           case 0xa1:
11138               GETBYTE ();
11139               switch (op[2] & 0x00)
11140               {
11141                 case 0x00:
11142                   goto op_semantics_91;
11143                   break;
11144               }
11145             break;
11146           case 0xa2:
11147               GETBYTE ();
11148               switch (op[2] & 0x00)
11149               {
11150                 case 0x00:
11151                   goto op_semantics_91;
11152                   break;
11153               }
11154             break;
11155           case 0xa3:
11156               GETBYTE ();
11157               switch (op[2] & 0x00)
11158               {
11159                 case 0x00:
11160                   goto op_semantics_91;
11161                   break;
11162               }
11163             break;
11164           case 0xa4:
11165               GETBYTE ();
11166               switch (op[2] & 0x00)
11167               {
11168                 case 0x00:
11169                   goto op_semantics_91;
11170                   break;
11171               }
11172             break;
11173           case 0xa5:
11174               GETBYTE ();
11175               switch (op[2] & 0x00)
11176               {
11177                 case 0x00:
11178                   goto op_semantics_91;
11179                   break;
11180               }
11181             break;
11182           case 0xa6:
11183               GETBYTE ();
11184               switch (op[2] & 0x00)
11185               {
11186                 case 0x00:
11187                   goto op_semantics_91;
11188                   break;
11189               }
11190             break;
11191           case 0xa7:
11192               GETBYTE ();
11193               switch (op[2] & 0x00)
11194               {
11195                 case 0x00:
11196                   goto op_semantics_91;
11197                   break;
11198               }
11199             break;
11200           case 0xa8:
11201               GETBYTE ();
11202               switch (op[2] & 0x00)
11203               {
11204                 case 0x00:
11205                   goto op_semantics_91;
11206                   break;
11207               }
11208             break;
11209           case 0xa9:
11210               GETBYTE ();
11211               switch (op[2] & 0x00)
11212               {
11213                 case 0x00:
11214                   goto op_semantics_91;
11215                   break;
11216               }
11217             break;
11218           case 0xaa:
11219               GETBYTE ();
11220               switch (op[2] & 0x00)
11221               {
11222                 case 0x00:
11223                   goto op_semantics_91;
11224                   break;
11225               }
11226             break;
11227           case 0xab:
11228               GETBYTE ();
11229               switch (op[2] & 0x00)
11230               {
11231                 case 0x00:
11232                   goto op_semantics_91;
11233                   break;
11234               }
11235             break;
11236           case 0xac:
11237               GETBYTE ();
11238               switch (op[2] & 0x00)
11239               {
11240                 case 0x00:
11241                   goto op_semantics_91;
11242                   break;
11243               }
11244             break;
11245           case 0xad:
11246               GETBYTE ();
11247               switch (op[2] & 0x00)
11248               {
11249                 case 0x00:
11250                   goto op_semantics_91;
11251                   break;
11252               }
11253             break;
11254           case 0xae:
11255               GETBYTE ();
11256               switch (op[2] & 0x00)
11257               {
11258                 case 0x00:
11259                   goto op_semantics_91;
11260                   break;
11261               }
11262             break;
11263           case 0xaf:
11264               GETBYTE ();
11265               switch (op[2] & 0x00)
11266               {
11267                 case 0x00:
11268                   goto op_semantics_91;
11269                   break;
11270               }
11271             break;
11272           case 0xb0:
11273               GETBYTE ();
11274               switch (op[2] & 0x00)
11275               {
11276                 case 0x00:
11277                   goto op_semantics_91;
11278                   break;
11279               }
11280             break;
11281           case 0xb1:
11282               GETBYTE ();
11283               switch (op[2] & 0x00)
11284               {
11285                 case 0x00:
11286                   goto op_semantics_91;
11287                   break;
11288               }
11289             break;
11290           case 0xb2:
11291               GETBYTE ();
11292               switch (op[2] & 0x00)
11293               {
11294                 case 0x00:
11295                   goto op_semantics_91;
11296                   break;
11297               }
11298             break;
11299           case 0xb3:
11300               GETBYTE ();
11301               switch (op[2] & 0x00)
11302               {
11303                 case 0x00:
11304                   goto op_semantics_91;
11305                   break;
11306               }
11307             break;
11308           case 0xb4:
11309               GETBYTE ();
11310               switch (op[2] & 0x00)
11311               {
11312                 case 0x00:
11313                   goto op_semantics_91;
11314                   break;
11315               }
11316             break;
11317           case 0xb5:
11318               GETBYTE ();
11319               switch (op[2] & 0x00)
11320               {
11321                 case 0x00:
11322                   goto op_semantics_91;
11323                   break;
11324               }
11325             break;
11326           case 0xb6:
11327               GETBYTE ();
11328               switch (op[2] & 0x00)
11329               {
11330                 case 0x00:
11331                   goto op_semantics_91;
11332                   break;
11333               }
11334             break;
11335           case 0xb7:
11336               GETBYTE ();
11337               switch (op[2] & 0x00)
11338               {
11339                 case 0x00:
11340                   goto op_semantics_91;
11341                   break;
11342               }
11343             break;
11344           case 0xb8:
11345               GETBYTE ();
11346               switch (op[2] & 0x00)
11347               {
11348                 case 0x00:
11349                   goto op_semantics_91;
11350                   break;
11351               }
11352             break;
11353           case 0xb9:
11354               GETBYTE ();
11355               switch (op[2] & 0x00)
11356               {
11357                 case 0x00:
11358                   goto op_semantics_91;
11359                   break;
11360               }
11361             break;
11362           case 0xba:
11363               GETBYTE ();
11364               switch (op[2] & 0x00)
11365               {
11366                 case 0x00:
11367                   goto op_semantics_91;
11368                   break;
11369               }
11370             break;
11371           case 0xbb:
11372               GETBYTE ();
11373               switch (op[2] & 0x00)
11374               {
11375                 case 0x00:
11376                   goto op_semantics_91;
11377                   break;
11378               }
11379             break;
11380           case 0xbc:
11381               GETBYTE ();
11382               switch (op[2] & 0x00)
11383               {
11384                 case 0x00:
11385                   goto op_semantics_91;
11386                   break;
11387               }
11388             break;
11389           case 0xbd:
11390               GETBYTE ();
11391               switch (op[2] & 0x00)
11392               {
11393                 case 0x00:
11394                   goto op_semantics_91;
11395                   break;
11396               }
11397             break;
11398           case 0xbe:
11399               GETBYTE ();
11400               switch (op[2] & 0x00)
11401               {
11402                 case 0x00:
11403                   goto op_semantics_91;
11404                   break;
11405               }
11406             break;
11407           case 0xbf:
11408               GETBYTE ();
11409               switch (op[2] & 0x00)
11410               {
11411                 case 0x00:
11412                   goto op_semantics_91;
11413                   break;
11414               }
11415             break;
11416           case 0xc0:
11417               GETBYTE ();
11418               switch (op[2] & 0x00)
11419               {
11420                 case 0x00:
11421                   op_semantics_92:
11422                     {
11423                       /** 1111 1101 110immmm rsrc rdst  shll    #%2, %1, %0 */
11424 #line 646 "rx-decode.opc"
11425                       int immmm AU = op[1] & 0x1f;
11426 #line 646 "rx-decode.opc"
11427                       int rsrc AU = (op[2] >> 4) & 0x0f;
11428 #line 646 "rx-decode.opc"
11429                       int rdst AU = op[2] & 0x0f;
11430                       if (trace)
11431                         {
11432                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11433                                  "/** 1111 1101 110immmm rsrc rdst      shll    #%2, %1, %0 */",
11434                                  op[0], op[1], op[2]);
11435                           printf ("  immmm = 0x%x,", immmm);
11436                           printf ("  rsrc = 0x%x,", rsrc);
11437                           printf ("  rdst = 0x%x\n", rdst);
11438                         }
11439                       SYNTAX("shll      #%2, %1, %0");
11440 #line 646 "rx-decode.opc"
11441                       ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F("OSZC");
11442
11443
11444                     }
11445                   break;
11446               }
11447             break;
11448           case 0xc1:
11449               GETBYTE ();
11450               switch (op[2] & 0x00)
11451               {
11452                 case 0x00:
11453                   goto op_semantics_92;
11454                   break;
11455               }
11456             break;
11457           case 0xc2:
11458               GETBYTE ();
11459               switch (op[2] & 0x00)
11460               {
11461                 case 0x00:
11462                   goto op_semantics_92;
11463                   break;
11464               }
11465             break;
11466           case 0xc3:
11467               GETBYTE ();
11468               switch (op[2] & 0x00)
11469               {
11470                 case 0x00:
11471                   goto op_semantics_92;
11472                   break;
11473               }
11474             break;
11475           case 0xc4:
11476               GETBYTE ();
11477               switch (op[2] & 0x00)
11478               {
11479                 case 0x00:
11480                   goto op_semantics_92;
11481                   break;
11482               }
11483             break;
11484           case 0xc5:
11485               GETBYTE ();
11486               switch (op[2] & 0x00)
11487               {
11488                 case 0x00:
11489                   goto op_semantics_92;
11490                   break;
11491               }
11492             break;
11493           case 0xc6:
11494               GETBYTE ();
11495               switch (op[2] & 0x00)
11496               {
11497                 case 0x00:
11498                   goto op_semantics_92;
11499                   break;
11500               }
11501             break;
11502           case 0xc7:
11503               GETBYTE ();
11504               switch (op[2] & 0x00)
11505               {
11506                 case 0x00:
11507                   goto op_semantics_92;
11508                   break;
11509               }
11510             break;
11511           case 0xc8:
11512               GETBYTE ();
11513               switch (op[2] & 0x00)
11514               {
11515                 case 0x00:
11516                   goto op_semantics_92;
11517                   break;
11518               }
11519             break;
11520           case 0xc9:
11521               GETBYTE ();
11522               switch (op[2] & 0x00)
11523               {
11524                 case 0x00:
11525                   goto op_semantics_92;
11526                   break;
11527               }
11528             break;
11529           case 0xca:
11530               GETBYTE ();
11531               switch (op[2] & 0x00)
11532               {
11533                 case 0x00:
11534                   goto op_semantics_92;
11535                   break;
11536               }
11537             break;
11538           case 0xcb:
11539               GETBYTE ();
11540               switch (op[2] & 0x00)
11541               {
11542                 case 0x00:
11543                   goto op_semantics_92;
11544                   break;
11545               }
11546             break;
11547           case 0xcc:
11548               GETBYTE ();
11549               switch (op[2] & 0x00)
11550               {
11551                 case 0x00:
11552                   goto op_semantics_92;
11553                   break;
11554               }
11555             break;
11556           case 0xcd:
11557               GETBYTE ();
11558               switch (op[2] & 0x00)
11559               {
11560                 case 0x00:
11561                   goto op_semantics_92;
11562                   break;
11563               }
11564             break;
11565           case 0xce:
11566               GETBYTE ();
11567               switch (op[2] & 0x00)
11568               {
11569                 case 0x00:
11570                   goto op_semantics_92;
11571                   break;
11572               }
11573             break;
11574           case 0xcf:
11575               GETBYTE ();
11576               switch (op[2] & 0x00)
11577               {
11578                 case 0x00:
11579                   goto op_semantics_92;
11580                   break;
11581               }
11582             break;
11583           case 0xd0:
11584               GETBYTE ();
11585               switch (op[2] & 0x00)
11586               {
11587                 case 0x00:
11588                   goto op_semantics_92;
11589                   break;
11590               }
11591             break;
11592           case 0xd1:
11593               GETBYTE ();
11594               switch (op[2] & 0x00)
11595               {
11596                 case 0x00:
11597                   goto op_semantics_92;
11598                   break;
11599               }
11600             break;
11601           case 0xd2:
11602               GETBYTE ();
11603               switch (op[2] & 0x00)
11604               {
11605                 case 0x00:
11606                   goto op_semantics_92;
11607                   break;
11608               }
11609             break;
11610           case 0xd3:
11611               GETBYTE ();
11612               switch (op[2] & 0x00)
11613               {
11614                 case 0x00:
11615                   goto op_semantics_92;
11616                   break;
11617               }
11618             break;
11619           case 0xd4:
11620               GETBYTE ();
11621               switch (op[2] & 0x00)
11622               {
11623                 case 0x00:
11624                   goto op_semantics_92;
11625                   break;
11626               }
11627             break;
11628           case 0xd5:
11629               GETBYTE ();
11630               switch (op[2] & 0x00)
11631               {
11632                 case 0x00:
11633                   goto op_semantics_92;
11634                   break;
11635               }
11636             break;
11637           case 0xd6:
11638               GETBYTE ();
11639               switch (op[2] & 0x00)
11640               {
11641                 case 0x00:
11642                   goto op_semantics_92;
11643                   break;
11644               }
11645             break;
11646           case 0xd7:
11647               GETBYTE ();
11648               switch (op[2] & 0x00)
11649               {
11650                 case 0x00:
11651                   goto op_semantics_92;
11652                   break;
11653               }
11654             break;
11655           case 0xd8:
11656               GETBYTE ();
11657               switch (op[2] & 0x00)
11658               {
11659                 case 0x00:
11660                   goto op_semantics_92;
11661                   break;
11662               }
11663             break;
11664           case 0xd9:
11665               GETBYTE ();
11666               switch (op[2] & 0x00)
11667               {
11668                 case 0x00:
11669                   goto op_semantics_92;
11670                   break;
11671               }
11672             break;
11673           case 0xda:
11674               GETBYTE ();
11675               switch (op[2] & 0x00)
11676               {
11677                 case 0x00:
11678                   goto op_semantics_92;
11679                   break;
11680               }
11681             break;
11682           case 0xdb:
11683               GETBYTE ();
11684               switch (op[2] & 0x00)
11685               {
11686                 case 0x00:
11687                   goto op_semantics_92;
11688                   break;
11689               }
11690             break;
11691           case 0xdc:
11692               GETBYTE ();
11693               switch (op[2] & 0x00)
11694               {
11695                 case 0x00:
11696                   goto op_semantics_92;
11697                   break;
11698               }
11699             break;
11700           case 0xdd:
11701               GETBYTE ();
11702               switch (op[2] & 0x00)
11703               {
11704                 case 0x00:
11705                   goto op_semantics_92;
11706                   break;
11707               }
11708             break;
11709           case 0xde:
11710               GETBYTE ();
11711               switch (op[2] & 0x00)
11712               {
11713                 case 0x00:
11714                   goto op_semantics_92;
11715                   break;
11716               }
11717             break;
11718           case 0xdf:
11719               GETBYTE ();
11720               switch (op[2] & 0x00)
11721               {
11722                 case 0x00:
11723                   goto op_semantics_92;
11724                   break;
11725               }
11726             break;
11727           case 0xe0:
11728               GETBYTE ();
11729               switch (op[2] & 0xf0)
11730               {
11731                 case 0x00:
11732                 case 0x10:
11733                 case 0x20:
11734                 case 0x30:
11735                 case 0x40:
11736                 case 0x50:
11737                 case 0x60:
11738                 case 0x70:
11739                 case 0x80:
11740                 case 0x90:
11741                 case 0xa0:
11742                 case 0xb0:
11743                 case 0xc0:
11744                 case 0xd0:
11745                 case 0xe0:
11746                   op_semantics_93:
11747                     {
11748                       /** 1111 1101 111 bittt cond rdst bm%2    #%1, %0%S0 */
11749 #line 912 "rx-decode.opc"
11750                       int bittt AU = op[1] & 0x1f;
11751 #line 912 "rx-decode.opc"
11752                       int cond AU = (op[2] >> 4) & 0x0f;
11753 #line 912 "rx-decode.opc"
11754                       int rdst AU = op[2] & 0x0f;
11755                       if (trace)
11756                         {
11757                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11758                                  "/** 1111 1101 111 bittt cond rdst     bm%2    #%1, %0%S0 */",
11759                                  op[0], op[1], op[2]);
11760                           printf ("  bittt = 0x%x,", bittt);
11761                           printf ("  cond = 0x%x,", cond);
11762                           printf ("  rdst = 0x%x\n", rdst);
11763                         }
11764                       SYNTAX("bm%2      #%1, %0%S0");
11765 #line 912 "rx-decode.opc"
11766                       ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
11767
11768                     /*----------------------------------------------------------------------*/
11769                     /* CONTROL REGISTERS                                                        */
11770
11771                     }
11772                   break;
11773                 case 0xf0:
11774                   op_semantics_94:
11775                     {
11776                       /** 1111 1101 111bittt 1111 rdst  bnot    #%1, %0 */
11777 #line 905 "rx-decode.opc"
11778                       int bittt AU = op[1] & 0x1f;
11779 #line 905 "rx-decode.opc"
11780                       int rdst AU = op[2] & 0x0f;
11781                       if (trace)
11782                         {
11783                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11784                                  "/** 1111 1101 111bittt 1111 rdst      bnot    #%1, %0 */",
11785                                  op[0], op[1], op[2]);
11786                           printf ("  bittt = 0x%x,", bittt);
11787                           printf ("  rdst = 0x%x\n", rdst);
11788                         }
11789                       SYNTAX("bnot      #%1, %0");
11790 #line 905 "rx-decode.opc"
11791                       ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
11792
11793
11794                     }
11795                   break;
11796               }
11797             break;
11798           case 0xe1:
11799               GETBYTE ();
11800               switch (op[2] & 0xf0)
11801               {
11802                 case 0x00:
11803                 case 0x10:
11804                 case 0x20:
11805                 case 0x30:
11806                 case 0x40:
11807                 case 0x50:
11808                 case 0x60:
11809                 case 0x70:
11810                 case 0x80:
11811                 case 0x90:
11812                 case 0xa0:
11813                 case 0xb0:
11814                 case 0xc0:
11815                 case 0xd0:
11816                 case 0xe0:
11817                   goto op_semantics_93;
11818                   break;
11819                 case 0xf0:
11820                   goto op_semantics_94;
11821                   break;
11822               }
11823             break;
11824           case 0xe2:
11825               GETBYTE ();
11826               switch (op[2] & 0xf0)
11827               {
11828                 case 0x00:
11829                 case 0x10:
11830                 case 0x20:
11831                 case 0x30:
11832                 case 0x40:
11833                 case 0x50:
11834                 case 0x60:
11835                 case 0x70:
11836                 case 0x80:
11837                 case 0x90:
11838                 case 0xa0:
11839                 case 0xb0:
11840                 case 0xc0:
11841                 case 0xd0:
11842                 case 0xe0:
11843                   goto op_semantics_93;
11844                   break;
11845                 case 0xf0:
11846                   goto op_semantics_94;
11847                   break;
11848               }
11849             break;
11850           case 0xe3:
11851               GETBYTE ();
11852               switch (op[2] & 0xf0)
11853               {
11854                 case 0x00:
11855                 case 0x10:
11856                 case 0x20:
11857                 case 0x30:
11858                 case 0x40:
11859                 case 0x50:
11860                 case 0x60:
11861                 case 0x70:
11862                 case 0x80:
11863                 case 0x90:
11864                 case 0xa0:
11865                 case 0xb0:
11866                 case 0xc0:
11867                 case 0xd0:
11868                 case 0xe0:
11869                   goto op_semantics_93;
11870                   break;
11871                 case 0xf0:
11872                   goto op_semantics_94;
11873                   break;
11874               }
11875             break;
11876           case 0xe4:
11877               GETBYTE ();
11878               switch (op[2] & 0xf0)
11879               {
11880                 case 0x00:
11881                 case 0x10:
11882                 case 0x20:
11883                 case 0x30:
11884                 case 0x40:
11885                 case 0x50:
11886                 case 0x60:
11887                 case 0x70:
11888                 case 0x80:
11889                 case 0x90:
11890                 case 0xa0:
11891                 case 0xb0:
11892                 case 0xc0:
11893                 case 0xd0:
11894                 case 0xe0:
11895                   goto op_semantics_93;
11896                   break;
11897                 case 0xf0:
11898                   goto op_semantics_94;
11899                   break;
11900               }
11901             break;
11902           case 0xe5:
11903               GETBYTE ();
11904               switch (op[2] & 0xf0)
11905               {
11906                 case 0x00:
11907                 case 0x10:
11908                 case 0x20:
11909                 case 0x30:
11910                 case 0x40:
11911                 case 0x50:
11912                 case 0x60:
11913                 case 0x70:
11914                 case 0x80:
11915                 case 0x90:
11916                 case 0xa0:
11917                 case 0xb0:
11918                 case 0xc0:
11919                 case 0xd0:
11920                 case 0xe0:
11921                   goto op_semantics_93;
11922                   break;
11923                 case 0xf0:
11924                   goto op_semantics_94;
11925                   break;
11926               }
11927             break;
11928           case 0xe6:
11929               GETBYTE ();
11930               switch (op[2] & 0xf0)
11931               {
11932                 case 0x00:
11933                 case 0x10:
11934                 case 0x20:
11935                 case 0x30:
11936                 case 0x40:
11937                 case 0x50:
11938                 case 0x60:
11939                 case 0x70:
11940                 case 0x80:
11941                 case 0x90:
11942                 case 0xa0:
11943                 case 0xb0:
11944                 case 0xc0:
11945                 case 0xd0:
11946                 case 0xe0:
11947                   goto op_semantics_93;
11948                   break;
11949                 case 0xf0:
11950                   goto op_semantics_94;
11951                   break;
11952               }
11953             break;
11954           case 0xe7:
11955               GETBYTE ();
11956               switch (op[2] & 0xf0)
11957               {
11958                 case 0x00:
11959                 case 0x10:
11960                 case 0x20:
11961                 case 0x30:
11962                 case 0x40:
11963                 case 0x50:
11964                 case 0x60:
11965                 case 0x70:
11966                 case 0x80:
11967                 case 0x90:
11968                 case 0xa0:
11969                 case 0xb0:
11970                 case 0xc0:
11971                 case 0xd0:
11972                 case 0xe0:
11973                   goto op_semantics_93;
11974                   break;
11975                 case 0xf0:
11976                   goto op_semantics_94;
11977                   break;
11978               }
11979             break;
11980           case 0xe8:
11981               GETBYTE ();
11982               switch (op[2] & 0xf0)
11983               {
11984                 case 0x00:
11985                 case 0x10:
11986                 case 0x20:
11987                 case 0x30:
11988                 case 0x40:
11989                 case 0x50:
11990                 case 0x60:
11991                 case 0x70:
11992                 case 0x80:
11993                 case 0x90:
11994                 case 0xa0:
11995                 case 0xb0:
11996                 case 0xc0:
11997                 case 0xd0:
11998                 case 0xe0:
11999                   goto op_semantics_93;
12000                   break;
12001                 case 0xf0:
12002                   goto op_semantics_94;
12003                   break;
12004               }
12005             break;
12006           case 0xe9:
12007               GETBYTE ();
12008               switch (op[2] & 0xf0)
12009               {
12010                 case 0x00:
12011                 case 0x10:
12012                 case 0x20:
12013                 case 0x30:
12014                 case 0x40:
12015                 case 0x50:
12016                 case 0x60:
12017                 case 0x70:
12018                 case 0x80:
12019                 case 0x90:
12020                 case 0xa0:
12021                 case 0xb0:
12022                 case 0xc0:
12023                 case 0xd0:
12024                 case 0xe0:
12025                   goto op_semantics_93;
12026                   break;
12027                 case 0xf0:
12028                   goto op_semantics_94;
12029                   break;
12030               }
12031             break;
12032           case 0xea:
12033               GETBYTE ();
12034               switch (op[2] & 0xf0)
12035               {
12036                 case 0x00:
12037                 case 0x10:
12038                 case 0x20:
12039                 case 0x30:
12040                 case 0x40:
12041                 case 0x50:
12042                 case 0x60:
12043                 case 0x70:
12044                 case 0x80:
12045                 case 0x90:
12046                 case 0xa0:
12047                 case 0xb0:
12048                 case 0xc0:
12049                 case 0xd0:
12050                 case 0xe0:
12051                   goto op_semantics_93;
12052                   break;
12053                 case 0xf0:
12054                   goto op_semantics_94;
12055                   break;
12056               }
12057             break;
12058           case 0xeb:
12059               GETBYTE ();
12060               switch (op[2] & 0xf0)
12061               {
12062                 case 0x00:
12063                 case 0x10:
12064                 case 0x20:
12065                 case 0x30:
12066                 case 0x40:
12067                 case 0x50:
12068                 case 0x60:
12069                 case 0x70:
12070                 case 0x80:
12071                 case 0x90:
12072                 case 0xa0:
12073                 case 0xb0:
12074                 case 0xc0:
12075                 case 0xd0:
12076                 case 0xe0:
12077                   goto op_semantics_93;
12078                   break;
12079                 case 0xf0:
12080                   goto op_semantics_94;
12081                   break;
12082               }
12083             break;
12084           case 0xec:
12085               GETBYTE ();
12086               switch (op[2] & 0xf0)
12087               {
12088                 case 0x00:
12089                 case 0x10:
12090                 case 0x20:
12091                 case 0x30:
12092                 case 0x40:
12093                 case 0x50:
12094                 case 0x60:
12095                 case 0x70:
12096                 case 0x80:
12097                 case 0x90:
12098                 case 0xa0:
12099                 case 0xb0:
12100                 case 0xc0:
12101                 case 0xd0:
12102                 case 0xe0:
12103                   goto op_semantics_93;
12104                   break;
12105                 case 0xf0:
12106                   goto op_semantics_94;
12107                   break;
12108               }
12109             break;
12110           case 0xed:
12111               GETBYTE ();
12112               switch (op[2] & 0xf0)
12113               {
12114                 case 0x00:
12115                 case 0x10:
12116                 case 0x20:
12117                 case 0x30:
12118                 case 0x40:
12119                 case 0x50:
12120                 case 0x60:
12121                 case 0x70:
12122                 case 0x80:
12123                 case 0x90:
12124                 case 0xa0:
12125                 case 0xb0:
12126                 case 0xc0:
12127                 case 0xd0:
12128                 case 0xe0:
12129                   goto op_semantics_93;
12130                   break;
12131                 case 0xf0:
12132                   goto op_semantics_94;
12133                   break;
12134               }
12135             break;
12136           case 0xee:
12137               GETBYTE ();
12138               switch (op[2] & 0xf0)
12139               {
12140                 case 0x00:
12141                 case 0x10:
12142                 case 0x20:
12143                 case 0x30:
12144                 case 0x40:
12145                 case 0x50:
12146                 case 0x60:
12147                 case 0x70:
12148                 case 0x80:
12149                 case 0x90:
12150                 case 0xa0:
12151                 case 0xb0:
12152                 case 0xc0:
12153                 case 0xd0:
12154                 case 0xe0:
12155                   goto op_semantics_93;
12156                   break;
12157                 case 0xf0:
12158                   goto op_semantics_94;
12159                   break;
12160               }
12161             break;
12162           case 0xef:
12163               GETBYTE ();
12164               switch (op[2] & 0xf0)
12165               {
12166                 case 0x00:
12167                 case 0x10:
12168                 case 0x20:
12169                 case 0x30:
12170                 case 0x40:
12171                 case 0x50:
12172                 case 0x60:
12173                 case 0x70:
12174                 case 0x80:
12175                 case 0x90:
12176                 case 0xa0:
12177                 case 0xb0:
12178                 case 0xc0:
12179                 case 0xd0:
12180                 case 0xe0:
12181                   goto op_semantics_93;
12182                   break;
12183                 case 0xf0:
12184                   goto op_semantics_94;
12185                   break;
12186               }
12187             break;
12188           case 0xf0:
12189               GETBYTE ();
12190               switch (op[2] & 0xf0)
12191               {
12192                 case 0x00:
12193                 case 0x10:
12194                 case 0x20:
12195                 case 0x30:
12196                 case 0x40:
12197                 case 0x50:
12198                 case 0x60:
12199                 case 0x70:
12200                 case 0x80:
12201                 case 0x90:
12202                 case 0xa0:
12203                 case 0xb0:
12204                 case 0xc0:
12205                 case 0xd0:
12206                 case 0xe0:
12207                   goto op_semantics_93;
12208                   break;
12209                 case 0xf0:
12210                   goto op_semantics_94;
12211                   break;
12212               }
12213             break;
12214           case 0xf1:
12215               GETBYTE ();
12216               switch (op[2] & 0xf0)
12217               {
12218                 case 0x00:
12219                 case 0x10:
12220                 case 0x20:
12221                 case 0x30:
12222                 case 0x40:
12223                 case 0x50:
12224                 case 0x60:
12225                 case 0x70:
12226                 case 0x80:
12227                 case 0x90:
12228                 case 0xa0:
12229                 case 0xb0:
12230                 case 0xc0:
12231                 case 0xd0:
12232                 case 0xe0:
12233                   goto op_semantics_93;
12234                   break;
12235                 case 0xf0:
12236                   goto op_semantics_94;
12237                   break;
12238               }
12239             break;
12240           case 0xf2:
12241               GETBYTE ();
12242               switch (op[2] & 0xf0)
12243               {
12244                 case 0x00:
12245                 case 0x10:
12246                 case 0x20:
12247                 case 0x30:
12248                 case 0x40:
12249                 case 0x50:
12250                 case 0x60:
12251                 case 0x70:
12252                 case 0x80:
12253                 case 0x90:
12254                 case 0xa0:
12255                 case 0xb0:
12256                 case 0xc0:
12257                 case 0xd0:
12258                 case 0xe0:
12259                   goto op_semantics_93;
12260                   break;
12261                 case 0xf0:
12262                   goto op_semantics_94;
12263                   break;
12264               }
12265             break;
12266           case 0xf3:
12267               GETBYTE ();
12268               switch (op[2] & 0xf0)
12269               {
12270                 case 0x00:
12271                 case 0x10:
12272                 case 0x20:
12273                 case 0x30:
12274                 case 0x40:
12275                 case 0x50:
12276                 case 0x60:
12277                 case 0x70:
12278                 case 0x80:
12279                 case 0x90:
12280                 case 0xa0:
12281                 case 0xb0:
12282                 case 0xc0:
12283                 case 0xd0:
12284                 case 0xe0:
12285                   goto op_semantics_93;
12286                   break;
12287                 case 0xf0:
12288                   goto op_semantics_94;
12289                   break;
12290               }
12291             break;
12292           case 0xf4:
12293               GETBYTE ();
12294               switch (op[2] & 0xf0)
12295               {
12296                 case 0x00:
12297                 case 0x10:
12298                 case 0x20:
12299                 case 0x30:
12300                 case 0x40:
12301                 case 0x50:
12302                 case 0x60:
12303                 case 0x70:
12304                 case 0x80:
12305                 case 0x90:
12306                 case 0xa0:
12307                 case 0xb0:
12308                 case 0xc0:
12309                 case 0xd0:
12310                 case 0xe0:
12311                   goto op_semantics_93;
12312                   break;
12313                 case 0xf0:
12314                   goto op_semantics_94;
12315                   break;
12316               }
12317             break;
12318           case 0xf5:
12319               GETBYTE ();
12320               switch (op[2] & 0xf0)
12321               {
12322                 case 0x00:
12323                 case 0x10:
12324                 case 0x20:
12325                 case 0x30:
12326                 case 0x40:
12327                 case 0x50:
12328                 case 0x60:
12329                 case 0x70:
12330                 case 0x80:
12331                 case 0x90:
12332                 case 0xa0:
12333                 case 0xb0:
12334                 case 0xc0:
12335                 case 0xd0:
12336                 case 0xe0:
12337                   goto op_semantics_93;
12338                   break;
12339                 case 0xf0:
12340                   goto op_semantics_94;
12341                   break;
12342               }
12343             break;
12344           case 0xf6:
12345               GETBYTE ();
12346               switch (op[2] & 0xf0)
12347               {
12348                 case 0x00:
12349                 case 0x10:
12350                 case 0x20:
12351                 case 0x30:
12352                 case 0x40:
12353                 case 0x50:
12354                 case 0x60:
12355                 case 0x70:
12356                 case 0x80:
12357                 case 0x90:
12358                 case 0xa0:
12359                 case 0xb0:
12360                 case 0xc0:
12361                 case 0xd0:
12362                 case 0xe0:
12363                   goto op_semantics_93;
12364                   break;
12365                 case 0xf0:
12366                   goto op_semantics_94;
12367                   break;
12368               }
12369             break;
12370           case 0xf7:
12371               GETBYTE ();
12372               switch (op[2] & 0xf0)
12373               {
12374                 case 0x00:
12375                 case 0x10:
12376                 case 0x20:
12377                 case 0x30:
12378                 case 0x40:
12379                 case 0x50:
12380                 case 0x60:
12381                 case 0x70:
12382                 case 0x80:
12383                 case 0x90:
12384                 case 0xa0:
12385                 case 0xb0:
12386                 case 0xc0:
12387                 case 0xd0:
12388                 case 0xe0:
12389                   goto op_semantics_93;
12390                   break;
12391                 case 0xf0:
12392                   goto op_semantics_94;
12393                   break;
12394               }
12395             break;
12396           case 0xf8:
12397               GETBYTE ();
12398               switch (op[2] & 0xf0)
12399               {
12400                 case 0x00:
12401                 case 0x10:
12402                 case 0x20:
12403                 case 0x30:
12404                 case 0x40:
12405                 case 0x50:
12406                 case 0x60:
12407                 case 0x70:
12408                 case 0x80:
12409                 case 0x90:
12410                 case 0xa0:
12411                 case 0xb0:
12412                 case 0xc0:
12413                 case 0xd0:
12414                 case 0xe0:
12415                   goto op_semantics_93;
12416                   break;
12417                 case 0xf0:
12418                   goto op_semantics_94;
12419                   break;
12420               }
12421             break;
12422           case 0xf9:
12423               GETBYTE ();
12424               switch (op[2] & 0xf0)
12425               {
12426                 case 0x00:
12427                 case 0x10:
12428                 case 0x20:
12429                 case 0x30:
12430                 case 0x40:
12431                 case 0x50:
12432                 case 0x60:
12433                 case 0x70:
12434                 case 0x80:
12435                 case 0x90:
12436                 case 0xa0:
12437                 case 0xb0:
12438                 case 0xc0:
12439                 case 0xd0:
12440                 case 0xe0:
12441                   goto op_semantics_93;
12442                   break;
12443                 case 0xf0:
12444                   goto op_semantics_94;
12445                   break;
12446               }
12447             break;
12448           case 0xfa:
12449               GETBYTE ();
12450               switch (op[2] & 0xf0)
12451               {
12452                 case 0x00:
12453                 case 0x10:
12454                 case 0x20:
12455                 case 0x30:
12456                 case 0x40:
12457                 case 0x50:
12458                 case 0x60:
12459                 case 0x70:
12460                 case 0x80:
12461                 case 0x90:
12462                 case 0xa0:
12463                 case 0xb0:
12464                 case 0xc0:
12465                 case 0xd0:
12466                 case 0xe0:
12467                   goto op_semantics_93;
12468                   break;
12469                 case 0xf0:
12470                   goto op_semantics_94;
12471                   break;
12472               }
12473             break;
12474           case 0xfb:
12475               GETBYTE ();
12476               switch (op[2] & 0xf0)
12477               {
12478                 case 0x00:
12479                 case 0x10:
12480                 case 0x20:
12481                 case 0x30:
12482                 case 0x40:
12483                 case 0x50:
12484                 case 0x60:
12485                 case 0x70:
12486                 case 0x80:
12487                 case 0x90:
12488                 case 0xa0:
12489                 case 0xb0:
12490                 case 0xc0:
12491                 case 0xd0:
12492                 case 0xe0:
12493                   goto op_semantics_93;
12494                   break;
12495                 case 0xf0:
12496                   goto op_semantics_94;
12497                   break;
12498               }
12499             break;
12500           case 0xfc:
12501               GETBYTE ();
12502               switch (op[2] & 0xf0)
12503               {
12504                 case 0x00:
12505                 case 0x10:
12506                 case 0x20:
12507                 case 0x30:
12508                 case 0x40:
12509                 case 0x50:
12510                 case 0x60:
12511                 case 0x70:
12512                 case 0x80:
12513                 case 0x90:
12514                 case 0xa0:
12515                 case 0xb0:
12516                 case 0xc0:
12517                 case 0xd0:
12518                 case 0xe0:
12519                   goto op_semantics_93;
12520                   break;
12521                 case 0xf0:
12522                   goto op_semantics_94;
12523                   break;
12524               }
12525             break;
12526           case 0xfd:
12527               GETBYTE ();
12528               switch (op[2] & 0xf0)
12529               {
12530                 case 0x00:
12531                 case 0x10:
12532                 case 0x20:
12533                 case 0x30:
12534                 case 0x40:
12535                 case 0x50:
12536                 case 0x60:
12537                 case 0x70:
12538                 case 0x80:
12539                 case 0x90:
12540                 case 0xa0:
12541                 case 0xb0:
12542                 case 0xc0:
12543                 case 0xd0:
12544                 case 0xe0:
12545                   goto op_semantics_93;
12546                   break;
12547                 case 0xf0:
12548                   goto op_semantics_94;
12549                   break;
12550               }
12551             break;
12552           case 0xfe:
12553               GETBYTE ();
12554               switch (op[2] & 0xf0)
12555               {
12556                 case 0x00:
12557                 case 0x10:
12558                 case 0x20:
12559                 case 0x30:
12560                 case 0x40:
12561                 case 0x50:
12562                 case 0x60:
12563                 case 0x70:
12564                 case 0x80:
12565                 case 0x90:
12566                 case 0xa0:
12567                 case 0xb0:
12568                 case 0xc0:
12569                 case 0xd0:
12570                 case 0xe0:
12571                   goto op_semantics_93;
12572                   break;
12573                 case 0xf0:
12574                   goto op_semantics_94;
12575                   break;
12576               }
12577             break;
12578           case 0xff:
12579               GETBYTE ();
12580               switch (op[2] & 0xf0)
12581               {
12582                 case 0x00:
12583                 case 0x10:
12584                 case 0x20:
12585                 case 0x30:
12586                 case 0x40:
12587                 case 0x50:
12588                 case 0x60:
12589                 case 0x70:
12590                 case 0x80:
12591                 case 0x90:
12592                 case 0xa0:
12593                 case 0xb0:
12594                 case 0xc0:
12595                 case 0xd0:
12596                 case 0xe0:
12597                   goto op_semantics_93;
12598                   break;
12599                 case 0xf0:
12600                   goto op_semantics_94;
12601                   break;
12602               }
12603             break;
12604           default: UNSUPPORTED(); break;
12605         }
12606       break;
12607     case 0xfe:
12608         GETBYTE ();
12609         switch (op[1] & 0xff)
12610         {
12611           case 0x00:
12612               GETBYTE ();
12613               switch (op[2] & 0x00)
12614               {
12615                 case 0x00:
12616                   op_semantics_95:
12617                     {
12618                       /** 1111 1110 00sz isrc bsrc rdst mov%s   %0, [%1, %2] */
12619 #line 318 "rx-decode.opc"
12620                       int sz AU = (op[1] >> 4) & 0x03;
12621 #line 318 "rx-decode.opc"
12622                       int isrc AU = op[1] & 0x0f;
12623 #line 318 "rx-decode.opc"
12624                       int bsrc AU = (op[2] >> 4) & 0x0f;
12625 #line 318 "rx-decode.opc"
12626                       int rdst AU = op[2] & 0x0f;
12627                       if (trace)
12628                         {
12629                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12630                                  "/** 1111 1110 00sz isrc bsrc rdst     mov%s   %0, [%1, %2] */",
12631                                  op[0], op[1], op[2]);
12632                           printf ("  sz = 0x%x,", sz);
12633                           printf ("  isrc = 0x%x,", isrc);
12634                           printf ("  bsrc = 0x%x,", bsrc);
12635                           printf ("  rdst = 0x%x\n", rdst);
12636                         }
12637                       SYNTAX("mov%s     %0, [%1, %2]");
12638 #line 318 "rx-decode.opc"
12639                       ID(movbir); sBWL(sz); DR(rdst); SR(isrc); S2R(bsrc); F("----");
12640
12641                     }
12642                   break;
12643               }
12644             break;
12645           case 0x01:
12646               GETBYTE ();
12647               switch (op[2] & 0x00)
12648               {
12649                 case 0x00:
12650                   goto op_semantics_95;
12651                   break;
12652               }
12653             break;
12654           case 0x02:
12655               GETBYTE ();
12656               switch (op[2] & 0x00)
12657               {
12658                 case 0x00:
12659                   goto op_semantics_95;
12660                   break;
12661               }
12662             break;
12663           case 0x03:
12664               GETBYTE ();
12665               switch (op[2] & 0x00)
12666               {
12667                 case 0x00:
12668                   goto op_semantics_95;
12669                   break;
12670               }
12671             break;
12672           case 0x04:
12673               GETBYTE ();
12674               switch (op[2] & 0x00)
12675               {
12676                 case 0x00:
12677                   goto op_semantics_95;
12678                   break;
12679               }
12680             break;
12681           case 0x05:
12682               GETBYTE ();
12683               switch (op[2] & 0x00)
12684               {
12685                 case 0x00:
12686                   goto op_semantics_95;
12687                   break;
12688               }
12689             break;
12690           case 0x06:
12691               GETBYTE ();
12692               switch (op[2] & 0x00)
12693               {
12694                 case 0x00:
12695                   goto op_semantics_95;
12696                   break;
12697               }
12698             break;
12699           case 0x07:
12700               GETBYTE ();
12701               switch (op[2] & 0x00)
12702               {
12703                 case 0x00:
12704                   goto op_semantics_95;
12705                   break;
12706               }
12707             break;
12708           case 0x08:
12709               GETBYTE ();
12710               switch (op[2] & 0x00)
12711               {
12712                 case 0x00:
12713                   goto op_semantics_95;
12714                   break;
12715               }
12716             break;
12717           case 0x09:
12718               GETBYTE ();
12719               switch (op[2] & 0x00)
12720               {
12721                 case 0x00:
12722                   goto op_semantics_95;
12723                   break;
12724               }
12725             break;
12726           case 0x0a:
12727               GETBYTE ();
12728               switch (op[2] & 0x00)
12729               {
12730                 case 0x00:
12731                   goto op_semantics_95;
12732                   break;
12733               }
12734             break;
12735           case 0x0b:
12736               GETBYTE ();
12737               switch (op[2] & 0x00)
12738               {
12739                 case 0x00:
12740                   goto op_semantics_95;
12741                   break;
12742               }
12743             break;
12744           case 0x0c:
12745               GETBYTE ();
12746               switch (op[2] & 0x00)
12747               {
12748                 case 0x00:
12749                   goto op_semantics_95;
12750                   break;
12751               }
12752             break;
12753           case 0x0d:
12754               GETBYTE ();
12755               switch (op[2] & 0x00)
12756               {
12757                 case 0x00:
12758                   goto op_semantics_95;
12759                   break;
12760               }
12761             break;
12762           case 0x0e:
12763               GETBYTE ();
12764               switch (op[2] & 0x00)
12765               {
12766                 case 0x00:
12767                   goto op_semantics_95;
12768                   break;
12769               }
12770             break;
12771           case 0x0f:
12772               GETBYTE ();
12773               switch (op[2] & 0x00)
12774               {
12775                 case 0x00:
12776                   goto op_semantics_95;
12777                   break;
12778               }
12779             break;
12780           case 0x10:
12781               GETBYTE ();
12782               switch (op[2] & 0x00)
12783               {
12784                 case 0x00:
12785                   goto op_semantics_95;
12786                   break;
12787               }
12788             break;
12789           case 0x11:
12790               GETBYTE ();
12791               switch (op[2] & 0x00)
12792               {
12793                 case 0x00:
12794                   goto op_semantics_95;
12795                   break;
12796               }
12797             break;
12798           case 0x12:
12799               GETBYTE ();
12800               switch (op[2] & 0x00)
12801               {
12802                 case 0x00:
12803                   goto op_semantics_95;
12804                   break;
12805               }
12806             break;
12807           case 0x13:
12808               GETBYTE ();
12809               switch (op[2] & 0x00)
12810               {
12811                 case 0x00:
12812                   goto op_semantics_95;
12813                   break;
12814               }
12815             break;
12816           case 0x14:
12817               GETBYTE ();
12818               switch (op[2] & 0x00)
12819               {
12820                 case 0x00:
12821                   goto op_semantics_95;
12822                   break;
12823               }
12824             break;
12825           case 0x15:
12826               GETBYTE ();
12827               switch (op[2] & 0x00)
12828               {
12829                 case 0x00:
12830                   goto op_semantics_95;
12831                   break;
12832               }
12833             break;
12834           case 0x16:
12835               GETBYTE ();
12836               switch (op[2] & 0x00)
12837               {
12838                 case 0x00:
12839                   goto op_semantics_95;
12840                   break;
12841               }
12842             break;
12843           case 0x17:
12844               GETBYTE ();
12845               switch (op[2] & 0x00)
12846               {
12847                 case 0x00:
12848                   goto op_semantics_95;
12849                   break;
12850               }
12851             break;
12852           case 0x18:
12853               GETBYTE ();
12854               switch (op[2] & 0x00)
12855               {
12856                 case 0x00:
12857                   goto op_semantics_95;
12858                   break;
12859               }
12860             break;
12861           case 0x19:
12862               GETBYTE ();
12863               switch (op[2] & 0x00)
12864               {
12865                 case 0x00:
12866                   goto op_semantics_95;
12867                   break;
12868               }
12869             break;
12870           case 0x1a:
12871               GETBYTE ();
12872               switch (op[2] & 0x00)
12873               {
12874                 case 0x00:
12875                   goto op_semantics_95;
12876                   break;
12877               }
12878             break;
12879           case 0x1b:
12880               GETBYTE ();
12881               switch (op[2] & 0x00)
12882               {
12883                 case 0x00:
12884                   goto op_semantics_95;
12885                   break;
12886               }
12887             break;
12888           case 0x1c:
12889               GETBYTE ();
12890               switch (op[2] & 0x00)
12891               {
12892                 case 0x00:
12893                   goto op_semantics_95;
12894                   break;
12895               }
12896             break;
12897           case 0x1d:
12898               GETBYTE ();
12899               switch (op[2] & 0x00)
12900               {
12901                 case 0x00:
12902                   goto op_semantics_95;
12903                   break;
12904               }
12905             break;
12906           case 0x1e:
12907               GETBYTE ();
12908               switch (op[2] & 0x00)
12909               {
12910                 case 0x00:
12911                   goto op_semantics_95;
12912                   break;
12913               }
12914             break;
12915           case 0x1f:
12916               GETBYTE ();
12917               switch (op[2] & 0x00)
12918               {
12919                 case 0x00:
12920                   goto op_semantics_95;
12921                   break;
12922               }
12923             break;
12924           case 0x20:
12925               GETBYTE ();
12926               switch (op[2] & 0x00)
12927               {
12928                 case 0x00:
12929                   goto op_semantics_95;
12930                   break;
12931               }
12932             break;
12933           case 0x21:
12934               GETBYTE ();
12935               switch (op[2] & 0x00)
12936               {
12937                 case 0x00:
12938                   goto op_semantics_95;
12939                   break;
12940               }
12941             break;
12942           case 0x22:
12943               GETBYTE ();
12944               switch (op[2] & 0x00)
12945               {
12946                 case 0x00:
12947                   goto op_semantics_95;
12948                   break;
12949               }
12950             break;
12951           case 0x23:
12952               GETBYTE ();
12953               switch (op[2] & 0x00)
12954               {
12955                 case 0x00:
12956                   goto op_semantics_95;
12957                   break;
12958               }
12959             break;
12960           case 0x24:
12961               GETBYTE ();
12962               switch (op[2] & 0x00)
12963               {
12964                 case 0x00:
12965                   goto op_semantics_95;
12966                   break;
12967               }
12968             break;
12969           case 0x25:
12970               GETBYTE ();
12971               switch (op[2] & 0x00)
12972               {
12973                 case 0x00:
12974                   goto op_semantics_95;
12975                   break;
12976               }
12977             break;
12978           case 0x26:
12979               GETBYTE ();
12980               switch (op[2] & 0x00)
12981               {
12982                 case 0x00:
12983                   goto op_semantics_95;
12984                   break;
12985               }
12986             break;
12987           case 0x27:
12988               GETBYTE ();
12989               switch (op[2] & 0x00)
12990               {
12991                 case 0x00:
12992                   goto op_semantics_95;
12993                   break;
12994               }
12995             break;
12996           case 0x28:
12997               GETBYTE ();
12998               switch (op[2] & 0x00)
12999               {
13000                 case 0x00:
13001                   goto op_semantics_95;
13002                   break;
13003               }
13004             break;
13005           case 0x29:
13006               GETBYTE ();
13007               switch (op[2] & 0x00)
13008               {
13009                 case 0x00:
13010                   goto op_semantics_95;
13011                   break;
13012               }
13013             break;
13014           case 0x2a:
13015               GETBYTE ();
13016               switch (op[2] & 0x00)
13017               {
13018                 case 0x00:
13019                   goto op_semantics_95;
13020                   break;
13021               }
13022             break;
13023           case 0x2b:
13024               GETBYTE ();
13025               switch (op[2] & 0x00)
13026               {
13027                 case 0x00:
13028                   goto op_semantics_95;
13029                   break;
13030               }
13031             break;
13032           case 0x2c:
13033               GETBYTE ();
13034               switch (op[2] & 0x00)
13035               {
13036                 case 0x00:
13037                   goto op_semantics_95;
13038                   break;
13039               }
13040             break;
13041           case 0x2d:
13042               GETBYTE ();
13043               switch (op[2] & 0x00)
13044               {
13045                 case 0x00:
13046                   goto op_semantics_95;
13047                   break;
13048               }
13049             break;
13050           case 0x2e:
13051               GETBYTE ();
13052               switch (op[2] & 0x00)
13053               {
13054                 case 0x00:
13055                   goto op_semantics_95;
13056                   break;
13057               }
13058             break;
13059           case 0x2f:
13060               GETBYTE ();
13061               switch (op[2] & 0x00)
13062               {
13063                 case 0x00:
13064                   goto op_semantics_95;
13065                   break;
13066               }
13067             break;
13068           case 0x40:
13069               GETBYTE ();
13070               switch (op[2] & 0x00)
13071               {
13072                 case 0x00:
13073                   op_semantics_96:
13074                     {
13075                       /** 1111 1110 01sz isrc bsrc rdst mov%s   [%1, %2], %0 */
13076 #line 315 "rx-decode.opc"
13077                       int sz AU = (op[1] >> 4) & 0x03;
13078 #line 315 "rx-decode.opc"
13079                       int isrc AU = op[1] & 0x0f;
13080 #line 315 "rx-decode.opc"
13081                       int bsrc AU = (op[2] >> 4) & 0x0f;
13082 #line 315 "rx-decode.opc"
13083                       int rdst AU = op[2] & 0x0f;
13084                       if (trace)
13085                         {
13086                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13087                                  "/** 1111 1110 01sz isrc bsrc rdst     mov%s   [%1, %2], %0 */",
13088                                  op[0], op[1], op[2]);
13089                           printf ("  sz = 0x%x,", sz);
13090                           printf ("  isrc = 0x%x,", isrc);
13091                           printf ("  bsrc = 0x%x,", bsrc);
13092                           printf ("  rdst = 0x%x\n", rdst);
13093                         }
13094                       SYNTAX("mov%s     [%1, %2], %0");
13095 #line 315 "rx-decode.opc"
13096                       ID(movbi); sBWL(sz); DR(rdst); SR(isrc); S2R(bsrc); F("----");
13097
13098                     }
13099                   break;
13100               }
13101             break;
13102           case 0x41:
13103               GETBYTE ();
13104               switch (op[2] & 0x00)
13105               {
13106                 case 0x00:
13107                   goto op_semantics_96;
13108                   break;
13109               }
13110             break;
13111           case 0x42:
13112               GETBYTE ();
13113               switch (op[2] & 0x00)
13114               {
13115                 case 0x00:
13116                   goto op_semantics_96;
13117                   break;
13118               }
13119             break;
13120           case 0x43:
13121               GETBYTE ();
13122               switch (op[2] & 0x00)
13123               {
13124                 case 0x00:
13125                   goto op_semantics_96;
13126                   break;
13127               }
13128             break;
13129           case 0x44:
13130               GETBYTE ();
13131               switch (op[2] & 0x00)
13132               {
13133                 case 0x00:
13134                   goto op_semantics_96;
13135                   break;
13136               }
13137             break;
13138           case 0x45:
13139               GETBYTE ();
13140               switch (op[2] & 0x00)
13141               {
13142                 case 0x00:
13143                   goto op_semantics_96;
13144                   break;
13145               }
13146             break;
13147           case 0x46:
13148               GETBYTE ();
13149               switch (op[2] & 0x00)
13150               {
13151                 case 0x00:
13152                   goto op_semantics_96;
13153                   break;
13154               }
13155             break;
13156           case 0x47:
13157               GETBYTE ();
13158               switch (op[2] & 0x00)
13159               {
13160                 case 0x00:
13161                   goto op_semantics_96;
13162                   break;
13163               }
13164             break;
13165           case 0x48:
13166               GETBYTE ();
13167               switch (op[2] & 0x00)
13168               {
13169                 case 0x00:
13170                   goto op_semantics_96;
13171                   break;
13172               }
13173             break;
13174           case 0x49:
13175               GETBYTE ();
13176               switch (op[2] & 0x00)
13177               {
13178                 case 0x00:
13179                   goto op_semantics_96;
13180                   break;
13181               }
13182             break;
13183           case 0x4a:
13184               GETBYTE ();
13185               switch (op[2] & 0x00)
13186               {
13187                 case 0x00:
13188                   goto op_semantics_96;
13189                   break;
13190               }
13191             break;
13192           case 0x4b:
13193               GETBYTE ();
13194               switch (op[2] & 0x00)
13195               {
13196                 case 0x00:
13197                   goto op_semantics_96;
13198                   break;
13199               }
13200             break;
13201           case 0x4c:
13202               GETBYTE ();
13203               switch (op[2] & 0x00)
13204               {
13205                 case 0x00:
13206                   goto op_semantics_96;
13207                   break;
13208               }
13209             break;
13210           case 0x4d:
13211               GETBYTE ();
13212               switch (op[2] & 0x00)
13213               {
13214                 case 0x00:
13215                   goto op_semantics_96;
13216                   break;
13217               }
13218             break;
13219           case 0x4e:
13220               GETBYTE ();
13221               switch (op[2] & 0x00)
13222               {
13223                 case 0x00:
13224                   goto op_semantics_96;
13225                   break;
13226               }
13227             break;
13228           case 0x4f:
13229               GETBYTE ();
13230               switch (op[2] & 0x00)
13231               {
13232                 case 0x00:
13233                   goto op_semantics_96;
13234                   break;
13235               }
13236             break;
13237           case 0x50:
13238               GETBYTE ();
13239               switch (op[2] & 0x00)
13240               {
13241                 case 0x00:
13242                   goto op_semantics_96;
13243                   break;
13244               }
13245             break;
13246           case 0x51:
13247               GETBYTE ();
13248               switch (op[2] & 0x00)
13249               {
13250                 case 0x00:
13251                   goto op_semantics_96;
13252                   break;
13253               }
13254             break;
13255           case 0x52:
13256               GETBYTE ();
13257               switch (op[2] & 0x00)
13258               {
13259                 case 0x00:
13260                   goto op_semantics_96;
13261                   break;
13262               }
13263             break;
13264           case 0x53:
13265               GETBYTE ();
13266               switch (op[2] & 0x00)
13267               {
13268                 case 0x00:
13269                   goto op_semantics_96;
13270                   break;
13271               }
13272             break;
13273           case 0x54:
13274               GETBYTE ();
13275               switch (op[2] & 0x00)
13276               {
13277                 case 0x00:
13278                   goto op_semantics_96;
13279                   break;
13280               }
13281             break;
13282           case 0x55:
13283               GETBYTE ();
13284               switch (op[2] & 0x00)
13285               {
13286                 case 0x00:
13287                   goto op_semantics_96;
13288                   break;
13289               }
13290             break;
13291           case 0x56:
13292               GETBYTE ();
13293               switch (op[2] & 0x00)
13294               {
13295                 case 0x00:
13296                   goto op_semantics_96;
13297                   break;
13298               }
13299             break;
13300           case 0x57:
13301               GETBYTE ();
13302               switch (op[2] & 0x00)
13303               {
13304                 case 0x00:
13305                   goto op_semantics_96;
13306                   break;
13307               }
13308             break;
13309           case 0x58:
13310               GETBYTE ();
13311               switch (op[2] & 0x00)
13312               {
13313                 case 0x00:
13314                   goto op_semantics_96;
13315                   break;
13316               }
13317             break;
13318           case 0x59:
13319               GETBYTE ();
13320               switch (op[2] & 0x00)
13321               {
13322                 case 0x00:
13323                   goto op_semantics_96;
13324                   break;
13325               }
13326             break;
13327           case 0x5a:
13328               GETBYTE ();
13329               switch (op[2] & 0x00)
13330               {
13331                 case 0x00:
13332                   goto op_semantics_96;
13333                   break;
13334               }
13335             break;
13336           case 0x5b:
13337               GETBYTE ();
13338               switch (op[2] & 0x00)
13339               {
13340                 case 0x00:
13341                   goto op_semantics_96;
13342                   break;
13343               }
13344             break;
13345           case 0x5c:
13346               GETBYTE ();
13347               switch (op[2] & 0x00)
13348               {
13349                 case 0x00:
13350                   goto op_semantics_96;
13351                   break;
13352               }
13353             break;
13354           case 0x5d:
13355               GETBYTE ();
13356               switch (op[2] & 0x00)
13357               {
13358                 case 0x00:
13359                   goto op_semantics_96;
13360                   break;
13361               }
13362             break;
13363           case 0x5e:
13364               GETBYTE ();
13365               switch (op[2] & 0x00)
13366               {
13367                 case 0x00:
13368                   goto op_semantics_96;
13369                   break;
13370               }
13371             break;
13372           case 0x5f:
13373               GETBYTE ();
13374               switch (op[2] & 0x00)
13375               {
13376                 case 0x00:
13377                   goto op_semantics_96;
13378                   break;
13379               }
13380             break;
13381           case 0x60:
13382               GETBYTE ();
13383               switch (op[2] & 0x00)
13384               {
13385                 case 0x00:
13386                   goto op_semantics_96;
13387                   break;
13388               }
13389             break;
13390           case 0x61:
13391               GETBYTE ();
13392               switch (op[2] & 0x00)
13393               {
13394                 case 0x00:
13395                   goto op_semantics_96;
13396                   break;
13397               }
13398             break;
13399           case 0x62:
13400               GETBYTE ();
13401               switch (op[2] & 0x00)
13402               {
13403                 case 0x00:
13404                   goto op_semantics_96;
13405                   break;
13406               }
13407             break;
13408           case 0x63:
13409               GETBYTE ();
13410               switch (op[2] & 0x00)
13411               {
13412                 case 0x00:
13413                   goto op_semantics_96;
13414                   break;
13415               }
13416             break;
13417           case 0x64:
13418               GETBYTE ();
13419               switch (op[2] & 0x00)
13420               {
13421                 case 0x00:
13422                   goto op_semantics_96;
13423                   break;
13424               }
13425             break;
13426           case 0x65:
13427               GETBYTE ();
13428               switch (op[2] & 0x00)
13429               {
13430                 case 0x00:
13431                   goto op_semantics_96;
13432                   break;
13433               }
13434             break;
13435           case 0x66:
13436               GETBYTE ();
13437               switch (op[2] & 0x00)
13438               {
13439                 case 0x00:
13440                   goto op_semantics_96;
13441                   break;
13442               }
13443             break;
13444           case 0x67:
13445               GETBYTE ();
13446               switch (op[2] & 0x00)
13447               {
13448                 case 0x00:
13449                   goto op_semantics_96;
13450                   break;
13451               }
13452             break;
13453           case 0x68:
13454               GETBYTE ();
13455               switch (op[2] & 0x00)
13456               {
13457                 case 0x00:
13458                   goto op_semantics_96;
13459                   break;
13460               }
13461             break;
13462           case 0x69:
13463               GETBYTE ();
13464               switch (op[2] & 0x00)
13465               {
13466                 case 0x00:
13467                   goto op_semantics_96;
13468                   break;
13469               }
13470             break;
13471           case 0x6a:
13472               GETBYTE ();
13473               switch (op[2] & 0x00)
13474               {
13475                 case 0x00:
13476                   goto op_semantics_96;
13477                   break;
13478               }
13479             break;
13480           case 0x6b:
13481               GETBYTE ();
13482               switch (op[2] & 0x00)
13483               {
13484                 case 0x00:
13485                   goto op_semantics_96;
13486                   break;
13487               }
13488             break;
13489           case 0x6c:
13490               GETBYTE ();
13491               switch (op[2] & 0x00)
13492               {
13493                 case 0x00:
13494                   goto op_semantics_96;
13495                   break;
13496               }
13497             break;
13498           case 0x6d:
13499               GETBYTE ();
13500               switch (op[2] & 0x00)
13501               {
13502                 case 0x00:
13503                   goto op_semantics_96;
13504                   break;
13505               }
13506             break;
13507           case 0x6e:
13508               GETBYTE ();
13509               switch (op[2] & 0x00)
13510               {
13511                 case 0x00:
13512                   goto op_semantics_96;
13513                   break;
13514               }
13515             break;
13516           case 0x6f:
13517               GETBYTE ();
13518               switch (op[2] & 0x00)
13519               {
13520                 case 0x00:
13521                   goto op_semantics_96;
13522                   break;
13523               }
13524             break;
13525           case 0xc0:
13526               GETBYTE ();
13527               switch (op[2] & 0x00)
13528               {
13529                 case 0x00:
13530                   op_semantics_97:
13531                     {
13532                       /** 1111 1110 11sz isrc bsrc rdst movu%s  [%1, %2], %0 */
13533 #line 321 "rx-decode.opc"
13534                       int sz AU = (op[1] >> 4) & 0x03;
13535 #line 321 "rx-decode.opc"
13536                       int isrc AU = op[1] & 0x0f;
13537 #line 321 "rx-decode.opc"
13538                       int bsrc AU = (op[2] >> 4) & 0x0f;
13539 #line 321 "rx-decode.opc"
13540                       int rdst AU = op[2] & 0x0f;
13541                       if (trace)
13542                         {
13543                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13544                                  "/** 1111 1110 11sz isrc bsrc rdst     movu%s  [%1, %2], %0 */",
13545                                  op[0], op[1], op[2]);
13546                           printf ("  sz = 0x%x,", sz);
13547                           printf ("  isrc = 0x%x,", isrc);
13548                           printf ("  bsrc = 0x%x,", bsrc);
13549                           printf ("  rdst = 0x%x\n", rdst);
13550                         }
13551                       SYNTAX("movu%s    [%1, %2], %0");
13552 #line 321 "rx-decode.opc"
13553                       ID(movbi); uBWL(sz); DR(rdst); SR(isrc); S2R(bsrc); F("----");
13554
13555                     }
13556                   break;
13557               }
13558             break;
13559           case 0xc1:
13560               GETBYTE ();
13561               switch (op[2] & 0x00)
13562               {
13563                 case 0x00:
13564                   goto op_semantics_97;
13565                   break;
13566               }
13567             break;
13568           case 0xc2:
13569               GETBYTE ();
13570               switch (op[2] & 0x00)
13571               {
13572                 case 0x00:
13573                   goto op_semantics_97;
13574                   break;
13575               }
13576             break;
13577           case 0xc3:
13578               GETBYTE ();
13579               switch (op[2] & 0x00)
13580               {
13581                 case 0x00:
13582                   goto op_semantics_97;
13583                   break;
13584               }
13585             break;
13586           case 0xc4:
13587               GETBYTE ();
13588               switch (op[2] & 0x00)
13589               {
13590                 case 0x00:
13591                   goto op_semantics_97;
13592                   break;
13593               }
13594             break;
13595           case 0xc5:
13596               GETBYTE ();
13597               switch (op[2] & 0x00)
13598               {
13599                 case 0x00:
13600                   goto op_semantics_97;
13601                   break;
13602               }
13603             break;
13604           case 0xc6:
13605               GETBYTE ();
13606               switch (op[2] & 0x00)
13607               {
13608                 case 0x00:
13609                   goto op_semantics_97;
13610                   break;
13611               }
13612             break;
13613           case 0xc7:
13614               GETBYTE ();
13615               switch (op[2] & 0x00)
13616               {
13617                 case 0x00:
13618                   goto op_semantics_97;
13619                   break;
13620               }
13621             break;
13622           case 0xc8:
13623               GETBYTE ();
13624               switch (op[2] & 0x00)
13625               {
13626                 case 0x00:
13627                   goto op_semantics_97;
13628                   break;
13629               }
13630             break;
13631           case 0xc9:
13632               GETBYTE ();
13633               switch (op[2] & 0x00)
13634               {
13635                 case 0x00:
13636                   goto op_semantics_97;
13637                   break;
13638               }
13639             break;
13640           case 0xca:
13641               GETBYTE ();
13642               switch (op[2] & 0x00)
13643               {
13644                 case 0x00:
13645                   goto op_semantics_97;
13646                   break;
13647               }
13648             break;
13649           case 0xcb:
13650               GETBYTE ();
13651               switch (op[2] & 0x00)
13652               {
13653                 case 0x00:
13654                   goto op_semantics_97;
13655                   break;
13656               }
13657             break;
13658           case 0xcc:
13659               GETBYTE ();
13660               switch (op[2] & 0x00)
13661               {
13662                 case 0x00:
13663                   goto op_semantics_97;
13664                   break;
13665               }
13666             break;
13667           case 0xcd:
13668               GETBYTE ();
13669               switch (op[2] & 0x00)
13670               {
13671                 case 0x00:
13672                   goto op_semantics_97;
13673                   break;
13674               }
13675             break;
13676           case 0xce:
13677               GETBYTE ();
13678               switch (op[2] & 0x00)
13679               {
13680                 case 0x00:
13681                   goto op_semantics_97;
13682                   break;
13683               }
13684             break;
13685           case 0xcf:
13686               GETBYTE ();
13687               switch (op[2] & 0x00)
13688               {
13689                 case 0x00:
13690                   goto op_semantics_97;
13691                   break;
13692               }
13693             break;
13694           case 0xd0:
13695               GETBYTE ();
13696               switch (op[2] & 0x00)
13697               {
13698                 case 0x00:
13699                   goto op_semantics_97;
13700                   break;
13701               }
13702             break;
13703           case 0xd1:
13704               GETBYTE ();
13705               switch (op[2] & 0x00)
13706               {
13707                 case 0x00:
13708                   goto op_semantics_97;
13709                   break;
13710               }
13711             break;
13712           case 0xd2:
13713               GETBYTE ();
13714               switch (op[2] & 0x00)
13715               {
13716                 case 0x00:
13717                   goto op_semantics_97;
13718                   break;
13719               }
13720             break;
13721           case 0xd3:
13722               GETBYTE ();
13723               switch (op[2] & 0x00)
13724               {
13725                 case 0x00:
13726                   goto op_semantics_97;
13727                   break;
13728               }
13729             break;
13730           case 0xd4:
13731               GETBYTE ();
13732               switch (op[2] & 0x00)
13733               {
13734                 case 0x00:
13735                   goto op_semantics_97;
13736                   break;
13737               }
13738             break;
13739           case 0xd5:
13740               GETBYTE ();
13741               switch (op[2] & 0x00)
13742               {
13743                 case 0x00:
13744                   goto op_semantics_97;
13745                   break;
13746               }
13747             break;
13748           case 0xd6:
13749               GETBYTE ();
13750               switch (op[2] & 0x00)
13751               {
13752                 case 0x00:
13753                   goto op_semantics_97;
13754                   break;
13755               }
13756             break;
13757           case 0xd7:
13758               GETBYTE ();
13759               switch (op[2] & 0x00)
13760               {
13761                 case 0x00:
13762                   goto op_semantics_97;
13763                   break;
13764               }
13765             break;
13766           case 0xd8:
13767               GETBYTE ();
13768               switch (op[2] & 0x00)
13769               {
13770                 case 0x00:
13771                   goto op_semantics_97;
13772                   break;
13773               }
13774             break;
13775           case 0xd9:
13776               GETBYTE ();
13777               switch (op[2] & 0x00)
13778               {
13779                 case 0x00:
13780                   goto op_semantics_97;
13781                   break;
13782               }
13783             break;
13784           case 0xda:
13785               GETBYTE ();
13786               switch (op[2] & 0x00)
13787               {
13788                 case 0x00:
13789                   goto op_semantics_97;
13790                   break;
13791               }
13792             break;
13793           case 0xdb:
13794               GETBYTE ();
13795               switch (op[2] & 0x00)
13796               {
13797                 case 0x00:
13798                   goto op_semantics_97;
13799                   break;
13800               }
13801             break;
13802           case 0xdc:
13803               GETBYTE ();
13804               switch (op[2] & 0x00)
13805               {
13806                 case 0x00:
13807                   goto op_semantics_97;
13808                   break;
13809               }
13810             break;
13811           case 0xdd:
13812               GETBYTE ();
13813               switch (op[2] & 0x00)
13814               {
13815                 case 0x00:
13816                   goto op_semantics_97;
13817                   break;
13818               }
13819             break;
13820           case 0xde:
13821               GETBYTE ();
13822               switch (op[2] & 0x00)
13823               {
13824                 case 0x00:
13825                   goto op_semantics_97;
13826                   break;
13827               }
13828             break;
13829           case 0xdf:
13830               GETBYTE ();
13831               switch (op[2] & 0x00)
13832               {
13833                 case 0x00:
13834                   goto op_semantics_97;
13835                   break;
13836               }
13837             break;
13838           case 0xe0:
13839               GETBYTE ();
13840               switch (op[2] & 0x00)
13841               {
13842                 case 0x00:
13843                   goto op_semantics_97;
13844                   break;
13845               }
13846             break;
13847           case 0xe1:
13848               GETBYTE ();
13849               switch (op[2] & 0x00)
13850               {
13851                 case 0x00:
13852                   goto op_semantics_97;
13853                   break;
13854               }
13855             break;
13856           case 0xe2:
13857               GETBYTE ();
13858               switch (op[2] & 0x00)
13859               {
13860                 case 0x00:
13861                   goto op_semantics_97;
13862                   break;
13863               }
13864             break;
13865           case 0xe3:
13866               GETBYTE ();
13867               switch (op[2] & 0x00)
13868               {
13869                 case 0x00:
13870                   goto op_semantics_97;
13871                   break;
13872               }
13873             break;
13874           case 0xe4:
13875               GETBYTE ();
13876               switch (op[2] & 0x00)
13877               {
13878                 case 0x00:
13879                   goto op_semantics_97;
13880                   break;
13881               }
13882             break;
13883           case 0xe5:
13884               GETBYTE ();
13885               switch (op[2] & 0x00)
13886               {
13887                 case 0x00:
13888                   goto op_semantics_97;
13889                   break;
13890               }
13891             break;
13892           case 0xe6:
13893               GETBYTE ();
13894               switch (op[2] & 0x00)
13895               {
13896                 case 0x00:
13897                   goto op_semantics_97;
13898                   break;
13899               }
13900             break;
13901           case 0xe7:
13902               GETBYTE ();
13903               switch (op[2] & 0x00)
13904               {
13905                 case 0x00:
13906                   goto op_semantics_97;
13907                   break;
13908               }
13909             break;
13910           case 0xe8:
13911               GETBYTE ();
13912               switch (op[2] & 0x00)
13913               {
13914                 case 0x00:
13915                   goto op_semantics_97;
13916                   break;
13917               }
13918             break;
13919           case 0xe9:
13920               GETBYTE ();
13921               switch (op[2] & 0x00)
13922               {
13923                 case 0x00:
13924                   goto op_semantics_97;
13925                   break;
13926               }
13927             break;
13928           case 0xea:
13929               GETBYTE ();
13930               switch (op[2] & 0x00)
13931               {
13932                 case 0x00:
13933                   goto op_semantics_97;
13934                   break;
13935               }
13936             break;
13937           case 0xeb:
13938               GETBYTE ();
13939               switch (op[2] & 0x00)
13940               {
13941                 case 0x00:
13942                   goto op_semantics_97;
13943                   break;
13944               }
13945             break;
13946           case 0xec:
13947               GETBYTE ();
13948               switch (op[2] & 0x00)
13949               {
13950                 case 0x00:
13951                   goto op_semantics_97;
13952                   break;
13953               }
13954             break;
13955           case 0xed:
13956               GETBYTE ();
13957               switch (op[2] & 0x00)
13958               {
13959                 case 0x00:
13960                   goto op_semantics_97;
13961                   break;
13962               }
13963             break;
13964           case 0xee:
13965               GETBYTE ();
13966               switch (op[2] & 0x00)
13967               {
13968                 case 0x00:
13969                   goto op_semantics_97;
13970                   break;
13971               }
13972             break;
13973           case 0xef:
13974               GETBYTE ();
13975               switch (op[2] & 0x00)
13976               {
13977                 case 0x00:
13978                   goto op_semantics_97;
13979                   break;
13980               }
13981             break;
13982           default: UNSUPPORTED(); break;
13983         }
13984       break;
13985     case 0xff:
13986         GETBYTE ();
13987         switch (op[1] & 0xff)
13988         {
13989           case 0x00:
13990               GETBYTE ();
13991               switch (op[2] & 0x00)
13992               {
13993                 case 0x00:
13994                   op_semantics_98:
13995                     {
13996                       /** 1111 1111 0000 rdst srca srcb sub     %2, %1, %0 */
13997 #line 525 "rx-decode.opc"
13998                       int rdst AU = op[1] & 0x0f;
13999 #line 525 "rx-decode.opc"
14000                       int srca AU = (op[2] >> 4) & 0x0f;
14001 #line 525 "rx-decode.opc"
14002                       int srcb AU = op[2] & 0x0f;
14003                       if (trace)
14004                         {
14005                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14006                                  "/** 1111 1111 0000 rdst srca srcb     sub     %2, %1, %0 */",
14007                                  op[0], op[1], op[2]);
14008                           printf ("  rdst = 0x%x,", rdst);
14009                           printf ("  srca = 0x%x,", srca);
14010                           printf ("  srcb = 0x%x\n", srcb);
14011                         }
14012                       SYNTAX("sub       %2, %1, %0");
14013 #line 525 "rx-decode.opc"
14014                       ID(sub); DR(rdst); SR(srcb); S2R(srca); F("OSZC");
14015
14016                     /*----------------------------------------------------------------------*/
14017                     /* SBB                                                                      */
14018
14019                     }
14020                   break;
14021               }
14022             break;
14023           case 0x01:
14024               GETBYTE ();
14025               switch (op[2] & 0x00)
14026               {
14027                 case 0x00:
14028                   goto op_semantics_98;
14029                   break;
14030               }
14031             break;
14032           case 0x02:
14033               GETBYTE ();
14034               switch (op[2] & 0x00)
14035               {
14036                 case 0x00:
14037                   goto op_semantics_98;
14038                   break;
14039               }
14040             break;
14041           case 0x03:
14042               GETBYTE ();
14043               switch (op[2] & 0x00)
14044               {
14045                 case 0x00:
14046                   goto op_semantics_98;
14047                   break;
14048               }
14049             break;
14050           case 0x04:
14051               GETBYTE ();
14052               switch (op[2] & 0x00)
14053               {
14054                 case 0x00:
14055                   goto op_semantics_98;
14056                   break;
14057               }
14058             break;
14059           case 0x05:
14060               GETBYTE ();
14061               switch (op[2] & 0x00)
14062               {
14063                 case 0x00:
14064                   goto op_semantics_98;
14065                   break;
14066               }
14067             break;
14068           case 0x06:
14069               GETBYTE ();
14070               switch (op[2] & 0x00)
14071               {
14072                 case 0x00:
14073                   goto op_semantics_98;
14074                   break;
14075               }
14076             break;
14077           case 0x07:
14078               GETBYTE ();
14079               switch (op[2] & 0x00)
14080               {
14081                 case 0x00:
14082                   goto op_semantics_98;
14083                   break;
14084               }
14085             break;
14086           case 0x08:
14087               GETBYTE ();
14088               switch (op[2] & 0x00)
14089               {
14090                 case 0x00:
14091                   goto op_semantics_98;
14092                   break;
14093               }
14094             break;
14095           case 0x09:
14096               GETBYTE ();
14097               switch (op[2] & 0x00)
14098               {
14099                 case 0x00:
14100                   goto op_semantics_98;
14101                   break;
14102               }
14103             break;
14104           case 0x0a:
14105               GETBYTE ();
14106               switch (op[2] & 0x00)
14107               {
14108                 case 0x00:
14109                   goto op_semantics_98;
14110                   break;
14111               }
14112             break;
14113           case 0x0b:
14114               GETBYTE ();
14115               switch (op[2] & 0x00)
14116               {
14117                 case 0x00:
14118                   goto op_semantics_98;
14119                   break;
14120               }
14121             break;
14122           case 0x0c:
14123               GETBYTE ();
14124               switch (op[2] & 0x00)
14125               {
14126                 case 0x00:
14127                   goto op_semantics_98;
14128                   break;
14129               }
14130             break;
14131           case 0x0d:
14132               GETBYTE ();
14133               switch (op[2] & 0x00)
14134               {
14135                 case 0x00:
14136                   goto op_semantics_98;
14137                   break;
14138               }
14139             break;
14140           case 0x0e:
14141               GETBYTE ();
14142               switch (op[2] & 0x00)
14143               {
14144                 case 0x00:
14145                   goto op_semantics_98;
14146                   break;
14147               }
14148             break;
14149           case 0x0f:
14150               GETBYTE ();
14151               switch (op[2] & 0x00)
14152               {
14153                 case 0x00:
14154                   goto op_semantics_98;
14155                   break;
14156               }
14157             break;
14158           case 0x20:
14159               GETBYTE ();
14160               switch (op[2] & 0x00)
14161               {
14162                 case 0x00:
14163                   op_semantics_99:
14164                     {
14165                       /** 1111 1111 0010 rdst srca srcb add     %2, %1, %0 */
14166 #line 492 "rx-decode.opc"
14167                       int rdst AU = op[1] & 0x0f;
14168 #line 492 "rx-decode.opc"
14169                       int srca AU = (op[2] >> 4) & 0x0f;
14170 #line 492 "rx-decode.opc"
14171                       int srcb AU = op[2] & 0x0f;
14172                       if (trace)
14173                         {
14174                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14175                                  "/** 1111 1111 0010 rdst srca srcb     add     %2, %1, %0 */",
14176                                  op[0], op[1], op[2]);
14177                           printf ("  rdst = 0x%x,", rdst);
14178                           printf ("  srca = 0x%x,", srca);
14179                           printf ("  srcb = 0x%x\n", srcb);
14180                         }
14181                       SYNTAX("add       %2, %1, %0");
14182 #line 492 "rx-decode.opc"
14183                       ID(add); DR(rdst); SR(srcb); S2R(srca); F("OSZC");
14184
14185                     /*----------------------------------------------------------------------*/
14186                     /* CMP                                                                      */
14187
14188                     }
14189                   break;
14190               }
14191             break;
14192           case 0x21:
14193               GETBYTE ();
14194               switch (op[2] & 0x00)
14195               {
14196                 case 0x00:
14197                   goto op_semantics_99;
14198                   break;
14199               }
14200             break;
14201           case 0x22:
14202               GETBYTE ();
14203               switch (op[2] & 0x00)
14204               {
14205                 case 0x00:
14206                   goto op_semantics_99;
14207                   break;
14208               }
14209             break;
14210           case 0x23:
14211               GETBYTE ();
14212               switch (op[2] & 0x00)
14213               {
14214                 case 0x00:
14215                   goto op_semantics_99;
14216                   break;
14217               }
14218             break;
14219           case 0x24:
14220               GETBYTE ();
14221               switch (op[2] & 0x00)
14222               {
14223                 case 0x00:
14224                   goto op_semantics_99;
14225                   break;
14226               }
14227             break;
14228           case 0x25:
14229               GETBYTE ();
14230               switch (op[2] & 0x00)
14231               {
14232                 case 0x00:
14233                   goto op_semantics_99;
14234                   break;
14235               }
14236             break;
14237           case 0x26:
14238               GETBYTE ();
14239               switch (op[2] & 0x00)
14240               {
14241                 case 0x00:
14242                   goto op_semantics_99;
14243                   break;
14244               }
14245             break;
14246           case 0x27:
14247               GETBYTE ();
14248               switch (op[2] & 0x00)
14249               {
14250                 case 0x00:
14251                   goto op_semantics_99;
14252                   break;
14253               }
14254             break;
14255           case 0x28:
14256               GETBYTE ();
14257               switch (op[2] & 0x00)
14258               {
14259                 case 0x00:
14260                   goto op_semantics_99;
14261                   break;
14262               }
14263             break;
14264           case 0x29:
14265               GETBYTE ();
14266               switch (op[2] & 0x00)
14267               {
14268                 case 0x00:
14269                   goto op_semantics_99;
14270                   break;
14271               }
14272             break;
14273           case 0x2a:
14274               GETBYTE ();
14275               switch (op[2] & 0x00)
14276               {
14277                 case 0x00:
14278                   goto op_semantics_99;
14279                   break;
14280               }
14281             break;
14282           case 0x2b:
14283               GETBYTE ();
14284               switch (op[2] & 0x00)
14285               {
14286                 case 0x00:
14287                   goto op_semantics_99;
14288                   break;
14289               }
14290             break;
14291           case 0x2c:
14292               GETBYTE ();
14293               switch (op[2] & 0x00)
14294               {
14295                 case 0x00:
14296                   goto op_semantics_99;
14297                   break;
14298               }
14299             break;
14300           case 0x2d:
14301               GETBYTE ();
14302               switch (op[2] & 0x00)
14303               {
14304                 case 0x00:
14305                   goto op_semantics_99;
14306                   break;
14307               }
14308             break;
14309           case 0x2e:
14310               GETBYTE ();
14311               switch (op[2] & 0x00)
14312               {
14313                 case 0x00:
14314                   goto op_semantics_99;
14315                   break;
14316               }
14317             break;
14318           case 0x2f:
14319               GETBYTE ();
14320               switch (op[2] & 0x00)
14321               {
14322                 case 0x00:
14323                   goto op_semantics_99;
14324                   break;
14325               }
14326             break;
14327           case 0x30:
14328               GETBYTE ();
14329               switch (op[2] & 0x00)
14330               {
14331                 case 0x00:
14332                   op_semantics_100:
14333                     {
14334                       /** 1111 1111 0011 rdst srca srcb mul     %2, %1, %0 */
14335 #line 586 "rx-decode.opc"
14336                       int rdst AU = op[1] & 0x0f;
14337 #line 586 "rx-decode.opc"
14338                       int srca AU = (op[2] >> 4) & 0x0f;
14339 #line 586 "rx-decode.opc"
14340                       int srcb AU = op[2] & 0x0f;
14341                       if (trace)
14342                         {
14343                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14344                                  "/** 1111 1111 0011 rdst srca srcb     mul     %2, %1, %0 */",
14345                                  op[0], op[1], op[2]);
14346                           printf ("  rdst = 0x%x,", rdst);
14347                           printf ("  srca = 0x%x,", srca);
14348                           printf ("  srcb = 0x%x\n", srcb);
14349                         }
14350                       SYNTAX("mul       %2, %1, %0");
14351 #line 586 "rx-decode.opc"
14352                       ID(mul); DR(rdst); SR(srcb); S2R(srca); F("----");
14353
14354                     /*----------------------------------------------------------------------*/
14355                     /* EMUL                                                                     */
14356
14357                     }
14358                   break;
14359               }
14360             break;
14361           case 0x31:
14362               GETBYTE ();
14363               switch (op[2] & 0x00)
14364               {
14365                 case 0x00:
14366                   goto op_semantics_100;
14367                   break;
14368               }
14369             break;
14370           case 0x32:
14371               GETBYTE ();
14372               switch (op[2] & 0x00)
14373               {
14374                 case 0x00:
14375                   goto op_semantics_100;
14376                   break;
14377               }
14378             break;
14379           case 0x33:
14380               GETBYTE ();
14381               switch (op[2] & 0x00)
14382               {
14383                 case 0x00:
14384                   goto op_semantics_100;
14385                   break;
14386               }
14387             break;
14388           case 0x34:
14389               GETBYTE ();
14390               switch (op[2] & 0x00)
14391               {
14392                 case 0x00:
14393                   goto op_semantics_100;
14394                   break;
14395               }
14396             break;
14397           case 0x35:
14398               GETBYTE ();
14399               switch (op[2] & 0x00)
14400               {
14401                 case 0x00:
14402                   goto op_semantics_100;
14403                   break;
14404               }
14405             break;
14406           case 0x36:
14407               GETBYTE ();
14408               switch (op[2] & 0x00)
14409               {
14410                 case 0x00:
14411                   goto op_semantics_100;
14412                   break;
14413               }
14414             break;
14415           case 0x37:
14416               GETBYTE ();
14417               switch (op[2] & 0x00)
14418               {
14419                 case 0x00:
14420                   goto op_semantics_100;
14421                   break;
14422               }
14423             break;
14424           case 0x38:
14425               GETBYTE ();
14426               switch (op[2] & 0x00)
14427               {
14428                 case 0x00:
14429                   goto op_semantics_100;
14430                   break;
14431               }
14432             break;
14433           case 0x39:
14434               GETBYTE ();
14435               switch (op[2] & 0x00)
14436               {
14437                 case 0x00:
14438                   goto op_semantics_100;
14439                   break;
14440               }
14441             break;
14442           case 0x3a:
14443               GETBYTE ();
14444               switch (op[2] & 0x00)
14445               {
14446                 case 0x00:
14447                   goto op_semantics_100;
14448                   break;
14449               }
14450             break;
14451           case 0x3b:
14452               GETBYTE ();
14453               switch (op[2] & 0x00)
14454               {
14455                 case 0x00:
14456                   goto op_semantics_100;
14457                   break;
14458               }
14459             break;
14460           case 0x3c:
14461               GETBYTE ();
14462               switch (op[2] & 0x00)
14463               {
14464                 case 0x00:
14465                   goto op_semantics_100;
14466                   break;
14467               }
14468             break;
14469           case 0x3d:
14470               GETBYTE ();
14471               switch (op[2] & 0x00)
14472               {
14473                 case 0x00:
14474                   goto op_semantics_100;
14475                   break;
14476               }
14477             break;
14478           case 0x3e:
14479               GETBYTE ();
14480               switch (op[2] & 0x00)
14481               {
14482                 case 0x00:
14483                   goto op_semantics_100;
14484                   break;
14485               }
14486             break;
14487           case 0x3f:
14488               GETBYTE ();
14489               switch (op[2] & 0x00)
14490               {
14491                 case 0x00:
14492                   goto op_semantics_100;
14493                   break;
14494               }
14495             break;
14496           case 0x40:
14497               GETBYTE ();
14498               switch (op[2] & 0x00)
14499               {
14500                 case 0x00:
14501                   op_semantics_101:
14502                     {
14503                       /** 1111 1111 0100 rdst srca srcb and     %2, %1, %0 */
14504 #line 402 "rx-decode.opc"
14505                       int rdst AU = op[1] & 0x0f;
14506 #line 402 "rx-decode.opc"
14507                       int srca AU = (op[2] >> 4) & 0x0f;
14508 #line 402 "rx-decode.opc"
14509                       int srcb AU = op[2] & 0x0f;
14510                       if (trace)
14511                         {
14512                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14513                                  "/** 1111 1111 0100 rdst srca srcb     and     %2, %1, %0 */",
14514                                  op[0], op[1], op[2]);
14515                           printf ("  rdst = 0x%x,", rdst);
14516                           printf ("  srca = 0x%x,", srca);
14517                           printf ("  srcb = 0x%x\n", srcb);
14518                         }
14519                       SYNTAX("and       %2, %1, %0");
14520 #line 402 "rx-decode.opc"
14521                       ID(and); DR(rdst); SR(srcb); S2R(srca); F("-SZ-");
14522
14523                     /*----------------------------------------------------------------------*/
14524                     /* OR                                                                       */
14525
14526                     }
14527                   break;
14528               }
14529             break;
14530           case 0x41:
14531               GETBYTE ();
14532               switch (op[2] & 0x00)
14533               {
14534                 case 0x00:
14535                   goto op_semantics_101;
14536                   break;
14537               }
14538             break;
14539           case 0x42:
14540               GETBYTE ();
14541               switch (op[2] & 0x00)
14542               {
14543                 case 0x00:
14544                   goto op_semantics_101;
14545                   break;
14546               }
14547             break;
14548           case 0x43:
14549               GETBYTE ();
14550               switch (op[2] & 0x00)
14551               {
14552                 case 0x00:
14553                   goto op_semantics_101;
14554                   break;
14555               }
14556             break;
14557           case 0x44:
14558               GETBYTE ();
14559               switch (op[2] & 0x00)
14560               {
14561                 case 0x00:
14562                   goto op_semantics_101;
14563                   break;
14564               }
14565             break;
14566           case 0x45:
14567               GETBYTE ();
14568               switch (op[2] & 0x00)
14569               {
14570                 case 0x00:
14571                   goto op_semantics_101;
14572                   break;
14573               }
14574             break;
14575           case 0x46:
14576               GETBYTE ();
14577               switch (op[2] & 0x00)
14578               {
14579                 case 0x00:
14580                   goto op_semantics_101;
14581                   break;
14582               }
14583             break;
14584           case 0x47:
14585               GETBYTE ();
14586               switch (op[2] & 0x00)
14587               {
14588                 case 0x00:
14589                   goto op_semantics_101;
14590                   break;
14591               }
14592             break;
14593           case 0x48:
14594               GETBYTE ();
14595               switch (op[2] & 0x00)
14596               {
14597                 case 0x00:
14598                   goto op_semantics_101;
14599                   break;
14600               }
14601             break;
14602           case 0x49:
14603               GETBYTE ();
14604               switch (op[2] & 0x00)
14605               {
14606                 case 0x00:
14607                   goto op_semantics_101;
14608                   break;
14609               }
14610             break;
14611           case 0x4a:
14612               GETBYTE ();
14613               switch (op[2] & 0x00)
14614               {
14615                 case 0x00:
14616                   goto op_semantics_101;
14617                   break;
14618               }
14619             break;
14620           case 0x4b:
14621               GETBYTE ();
14622               switch (op[2] & 0x00)
14623               {
14624                 case 0x00:
14625                   goto op_semantics_101;
14626                   break;
14627               }
14628             break;
14629           case 0x4c:
14630               GETBYTE ();
14631               switch (op[2] & 0x00)
14632               {
14633                 case 0x00:
14634                   goto op_semantics_101;
14635                   break;
14636               }
14637             break;
14638           case 0x4d:
14639               GETBYTE ();
14640               switch (op[2] & 0x00)
14641               {
14642                 case 0x00:
14643                   goto op_semantics_101;
14644                   break;
14645               }
14646             break;
14647           case 0x4e:
14648               GETBYTE ();
14649               switch (op[2] & 0x00)
14650               {
14651                 case 0x00:
14652                   goto op_semantics_101;
14653                   break;
14654               }
14655             break;
14656           case 0x4f:
14657               GETBYTE ();
14658               switch (op[2] & 0x00)
14659               {
14660                 case 0x00:
14661                   goto op_semantics_101;
14662                   break;
14663               }
14664             break;
14665           case 0x50:
14666               GETBYTE ();
14667               switch (op[2] & 0x00)
14668               {
14669                 case 0x00:
14670                   op_semantics_102:
14671                     {
14672                       /** 1111 1111 0101 rdst srca srcb or      %2, %1, %0 */
14673 #line 420 "rx-decode.opc"
14674                       int rdst AU = op[1] & 0x0f;
14675 #line 420 "rx-decode.opc"
14676                       int srca AU = (op[2] >> 4) & 0x0f;
14677 #line 420 "rx-decode.opc"
14678                       int srcb AU = op[2] & 0x0f;
14679                       if (trace)
14680                         {
14681                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14682                                  "/** 1111 1111 0101 rdst srca srcb     or      %2, %1, %0 */",
14683                                  op[0], op[1], op[2]);
14684                           printf ("  rdst = 0x%x,", rdst);
14685                           printf ("  srca = 0x%x,", srca);
14686                           printf ("  srcb = 0x%x\n", srcb);
14687                         }
14688                       SYNTAX("or        %2, %1, %0");
14689 #line 420 "rx-decode.opc"
14690                       ID(or); DR(rdst); SR(srcb); S2R(srca); F("-SZ-");
14691
14692                     /*----------------------------------------------------------------------*/
14693                     /* XOR                                                                      */
14694
14695                     }
14696                   break;
14697               }
14698             break;
14699           case 0x51:
14700               GETBYTE ();
14701               switch (op[2] & 0x00)
14702               {
14703                 case 0x00:
14704                   goto op_semantics_102;
14705                   break;
14706               }
14707             break;
14708           case 0x52:
14709               GETBYTE ();
14710               switch (op[2] & 0x00)
14711               {
14712                 case 0x00:
14713                   goto op_semantics_102;
14714                   break;
14715               }
14716             break;
14717           case 0x53:
14718               GETBYTE ();
14719               switch (op[2] & 0x00)
14720               {
14721                 case 0x00:
14722                   goto op_semantics_102;
14723                   break;
14724               }
14725             break;
14726           case 0x54:
14727               GETBYTE ();
14728               switch (op[2] & 0x00)
14729               {
14730                 case 0x00:
14731                   goto op_semantics_102;
14732                   break;
14733               }
14734             break;
14735           case 0x55:
14736               GETBYTE ();
14737               switch (op[2] & 0x00)
14738               {
14739                 case 0x00:
14740                   goto op_semantics_102;
14741                   break;
14742               }
14743             break;
14744           case 0x56:
14745               GETBYTE ();
14746               switch (op[2] & 0x00)
14747               {
14748                 case 0x00:
14749                   goto op_semantics_102;
14750                   break;
14751               }
14752             break;
14753           case 0x57:
14754               GETBYTE ();
14755               switch (op[2] & 0x00)
14756               {
14757                 case 0x00:
14758                   goto op_semantics_102;
14759                   break;
14760               }
14761             break;
14762           case 0x58:
14763               GETBYTE ();
14764               switch (op[2] & 0x00)
14765               {
14766                 case 0x00:
14767                   goto op_semantics_102;
14768                   break;
14769               }
14770             break;
14771           case 0x59:
14772               GETBYTE ();
14773               switch (op[2] & 0x00)
14774               {
14775                 case 0x00:
14776                   goto op_semantics_102;
14777                   break;
14778               }
14779             break;
14780           case 0x5a:
14781               GETBYTE ();
14782               switch (op[2] & 0x00)
14783               {
14784                 case 0x00:
14785                   goto op_semantics_102;
14786                   break;
14787               }
14788             break;
14789           case 0x5b:
14790               GETBYTE ();
14791               switch (op[2] & 0x00)
14792               {
14793                 case 0x00:
14794                   goto op_semantics_102;
14795                   break;
14796               }
14797             break;
14798           case 0x5c:
14799               GETBYTE ();
14800               switch (op[2] & 0x00)
14801               {
14802                 case 0x00:
14803                   goto op_semantics_102;
14804                   break;
14805               }
14806             break;
14807           case 0x5d:
14808               GETBYTE ();
14809               switch (op[2] & 0x00)
14810               {
14811                 case 0x00:
14812                   goto op_semantics_102;
14813                   break;
14814               }
14815             break;
14816           case 0x5e:
14817               GETBYTE ();
14818               switch (op[2] & 0x00)
14819               {
14820                 case 0x00:
14821                   goto op_semantics_102;
14822                   break;
14823               }
14824             break;
14825           case 0x5f:
14826               GETBYTE ();
14827               switch (op[2] & 0x00)
14828               {
14829                 case 0x00:
14830                   goto op_semantics_102;
14831                   break;
14832               }
14833             break;
14834           default: UNSUPPORTED(); break;
14835         }
14836       break;
14837     default: UNSUPPORTED(); break;
14838   }
14839 #line 969 "rx-decode.opc"
14840
14841   return rx->n_bytes;
14842 }