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