opcodes/rx-decode.c

   1 #line 1 "rx-decode.opc"
   2 /* -*- c -*- */
   3 #include "sysdep.h"
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include "ansidecl.h"
   8 #include "opcode/rx.h"
   9
  10 #define RX_OPCODE_BIG_ENDIAN 0
  11
  12 typedef struct
  13 {
  14   RX_Opcode_Decoded * rx;
  15   int (* getbyte)(void *);
  16   void * ptr;
  17   unsigned char * op;
  18 } LocalData;
  19
  20 static int trace = 0;
  21
  22 #define BSIZE 0
  23 #define WSIZE 1
  24 #define LSIZE 2
  25
  26 /* These are for when the upper bits are "don't care" or "undefined".  */
  27 static int bwl[] =
  28 {
  29   RX_Byte,
  30   RX_Word,
  31   RX_Long
  32 };
  33
  34 static int sbwl[] =
  35 {
  36   RX_SByte,
  37   RX_SWord,
  38   RX_Long
  39 };
  40
  41 static int ubwl[] =
  42 {
  43   RX_UByte,
  44   RX_UWord,
  45   RX_Long
  46 };
  47
  48 static int memex[] =
  49 {
  50   RX_SByte,
  51   RX_SWord,
  52   RX_Long,
  53   RX_UWord
  54 };
  55
  56 #define ID(x) rx->id = RXO_##x
  57 #define OP(n,t,r,a) (rx->op[n].type = t, \
  58                      rx->op[n].reg = r,      \
  59                      rx->op[n].addend = a )
  60 #define OPs(n,t,r,a,s) (OP (n,t,r,a), \
  61                         rx->op[n].size = s )
  62
  63 /* This is for the BWL and BW bitfields.  */
  64 static int SCALE[] = { 1, 2, 4 };
  65 /* This is for the prefix size enum.  */
  66 static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
  67
  68 static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
  69                        16, 17, 0, 0, 0, 0, 0, 0 };
  70
  71 static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
  72
  73 /*
  74  *C     a constant (immediate) c
  75  *R     A register
  76  *I     Register indirect, no offset
  77  *Is    Register indirect, with offset
  78  *D     standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
  79  *P     standard displacement: type (r,[r]), reg, assumes UByte
  80  *Pm    memex displacement: type (r,[r]), reg, memex code
  81  *cc    condition code.  */
  82
  83 #define DC(c)       OP (0, RX_Operand_Immediate, 0, c)
  84 #define DR(r)       OP (0, RX_Operand_Register,  r, 0)
  85 #define DI(r,a)     OP (0, RX_Operand_Indirect,  r, a)
  86 #define DIs(r,a,s)  OP (0, RX_Operand_Indirect,  r, (a) * SCALE[s])
  87 #define DD(t,r,s)   rx_disp (0, t, r, bwl[s], ld);
  88 #define DF(r)       OP (0, RX_Operand_Flag,  flagmap[r], 0)
  89
  90 #define SC(i)       OP (1, RX_Operand_Immediate, 0, i)
  91 #define SR(r)       OP (1, RX_Operand_Register,  r, 0)
  92 #define SRR(r)      OP (1, RX_Operand_TwoReg,  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 955 "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 958 "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 744 "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 750 "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 722 "rx-decode.opc"
 340           ID(branch); 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 738 "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 518 "rx-decode.opc"
 372                       int mx AU = (op[1] >> 6) & 0x03;
 373 #line 518 "rx-decode.opc"
 374                       int ss AU = op[1] & 0x03;
 375 #line 518 "rx-decode.opc"
 376                       int rsrc AU = (op[2] >> 4) & 0x0f;
 377 #line 518 "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 518 "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 506 "rx-decode.opc"
 433                       int mx AU = (op[1] >> 6) & 0x03;
 434 #line 506 "rx-decode.opc"
 435                       int ss AU = op[1] & 0x03;
 436 #line 506 "rx-decode.opc"
 437                       int rsrc AU = (op[2] >> 4) & 0x0f;
 438 #line 506 "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 506 "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 482 "rx-decode.opc"
 497                       int mx AU = (op[1] >> 6) & 0x03;
 498 #line 482 "rx-decode.opc"
 499                       int ss AU = op[1] & 0x03;
 500 #line 482 "rx-decode.opc"
 501                       int rsrc AU = (op[2] >> 4) & 0x0f;
 502 #line 482 "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 482 "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 587 "rx-decode.opc"
 558                       int mx AU = (op[1] >> 6) & 0x03;
 559 #line 587 "rx-decode.opc"
 560                       int ss AU = op[1] & 0x03;
 561 #line 587 "rx-decode.opc"
 562                       int rsrc AU = (op[2] >> 4) & 0x0f;
 563 #line 587 "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 587 "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 395 "rx-decode.opc"
 619                       int mx AU = (op[1] >> 6) & 0x03;
 620 #line 395 "rx-decode.opc"
 621                       int ss AU = op[1] & 0x03;
 622 #line 395 "rx-decode.opc"
 623                       int rsrc AU = (op[2] >> 4) & 0x0f;
 624 #line 395 "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 395 "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 413 "rx-decode.opc"
 680                       int mx AU = (op[1] >> 6) & 0x03;
 681 #line 413 "rx-decode.opc"
 682                       int ss AU = op[1] & 0x03;
 683 #line 413 "rx-decode.opc"
 684                       int rsrc AU = (op[2] >> 4) & 0x0f;
 685 #line 413 "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 413 "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 531 "rx-decode.opc"
 745                             int mx AU = (op[1] >> 6) & 0x03;
 746 #line 531 "rx-decode.opc"
 747                             int sp AU = op[1] & 0x03;
 748 #line 531 "rx-decode.opc"
 749                             int rsrc AU = (op[3] >> 4) & 0x0f;
 750 #line 531 "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 531 "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 560 "rx-decode.opc"
 782                             int mx AU = (op[1] >> 6) & 0x03;
 783 #line 560 "rx-decode.opc"
 784                             int ss AU = op[1] & 0x03;
 785 #line 560 "rx-decode.opc"
 786                             int rsrc AU = (op[3] >> 4) & 0x0f;
 787 #line 560 "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 560 "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 572 "rx-decode.opc"
 819                             int mx AU = (op[1] >> 6) & 0x03;
 820 #line 572 "rx-decode.opc"
 821                             int ss AU = op[1] & 0x03;
 822 #line 572 "rx-decode.opc"
 823                             int rsrc AU = (op[3] >> 4) & 0x0f;
 824 #line 572 "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 572 "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 602 "rx-decode.opc"
 856                             int mx AU = (op[1] >> 6) & 0x03;
 857 #line 602 "rx-decode.opc"
 858                             int ss AU = op[1] & 0x03;
 859 #line 602 "rx-decode.opc"
 860                             int rsrc AU = (op[3] >> 4) & 0x0f;
 861 #line 602 "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 602 "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 614 "rx-decode.opc"
 893                             int mx AU = (op[1] >> 6) & 0x03;
 894 #line 614 "rx-decode.opc"
 895                             int ss AU = op[1] & 0x03;
 896 #line 614 "rx-decode.opc"
 897                             int rsrc AU = (op[3] >> 4) & 0x0f;
 898 #line 614 "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 614 "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 626 "rx-decode.opc"
 930                             int mx AU = (op[1] >> 6) & 0x03;
 931 #line 626 "rx-decode.opc"
 932                             int ss AU = op[1] & 0x03;
 933 #line 626 "rx-decode.opc"
 934                             int rsrc AU = (op[3] >> 4) & 0x0f;
 935 #line 626 "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 626 "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 638 "rx-decode.opc"
 967                             int mx AU = (op[1] >> 6) & 0x03;
 968 #line 638 "rx-decode.opc"
 969                             int ss AU = op[1] & 0x03;
 970 #line 638 "rx-decode.opc"
 971                             int rsrc AU = (op[3] >> 4) & 0x0f;
 972 #line 638 "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 638 "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 449 "rx-decode.opc"
1004                             int mx AU = (op[1] >> 6) & 0x03;
1005 #line 449 "rx-decode.opc"
1006                             int ss AU = op[1] & 0x03;
1007 #line 449 "rx-decode.opc"
1008                             int rsrc AU = (op[3] >> 4) & 0x0f;
1009 #line 449 "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 449 "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 428 "rx-decode.opc"
1041                             int mx AU = (op[1] >> 6) & 0x03;
1042 #line 428 "rx-decode.opc"
1043                             int ss AU = op[1] & 0x03;
1044 #line 428 "rx-decode.opc"
1045                             int rsrc AU = (op[3] >> 4) & 0x0f;
1046 #line 428 "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 428 "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 362 "rx-decode.opc"
1078                             int mx AU = (op[1] >> 6) & 0x03;
1079 #line 362 "rx-decode.opc"
1080                             int ss AU = op[1] & 0x03;
1081 #line 362 "rx-decode.opc"
1082                             int rsrc AU = (op[3] >> 4) & 0x0f;
1083 #line 362 "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 362 "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 867 "rx-decode.opc"
1115                             int mx AU = (op[1] >> 6) & 0x03;
1116 #line 867 "rx-decode.opc"
1117                             int sd AU = op[1] & 0x03;
1118 #line 867 "rx-decode.opc"
1119                             int rsrc AU = (op[3] >> 4) & 0x0f;
1120 #line 867 "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 867 "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 470 "rx-decode.opc"
2342                             int ss AU = op[1] & 0x03;
2343 #line 470 "rx-decode.opc"
2344                             int rsrc AU = (op[3] >> 4) & 0x0f;
2345 #line 470 "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 470 "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 713 "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 713 "rx-decode.opc"
3469           ID(branch); 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 703 "rx-decode.opc"
3492           int n AU = (op[0] >> 3) & 0x01;
3493 #line 703 "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 703 "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 706 "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 706 "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 716 "rx-decode.opc"
3552           ID(branch); 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 719 "rx-decode.opc"
3567           ID(branch); 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 735 "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 709 "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 709 "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 283 "rx-decode.opc"
3615                 int sz AU = op[0] & 0x03;
3616 #line 283 "rx-decode.opc"
3617                 int d AU = (op[1] >> 7) & 0x01;
3618 #line 283 "rx-decode.opc"
3619                 int dst AU = (op[1] >> 4) & 0x07;
3620 #line 283 "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 283 "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 380 "rx-decode.opc"
3666                 int rega AU = (op[1] >> 4) & 0x0f;
3667 #line 380 "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 380 "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 515 "rx-decode.opc"
3697                 int ss AU = op[0] & 0x03;
3698 #line 515 "rx-decode.opc"
3699                 int rsrc AU = (op[1] >> 4) & 0x0f;
3700 #line 515 "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 515 "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 503 "rx-decode.opc"
3755                 int ss AU = op[0] & 0x03;
3756 #line 503 "rx-decode.opc"
3757                 int rsrc AU = (op[1] >> 4) & 0x0f;
3758 #line 503 "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 503 "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 479 "rx-decode.opc"
3813                 int ss AU = op[0] & 0x03;
3814 #line 479 "rx-decode.opc"
3815                 int rsrc AU = (op[1] >> 4) & 0x0f;
3816 #line 479 "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 479 "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 584 "rx-decode.opc"
3871                 int ss AU = op[0] & 0x03;
3872 #line 584 "rx-decode.opc"
3873                 int rsrc AU = (op[1] >> 4) & 0x0f;
3874 #line 584 "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 584 "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 392 "rx-decode.opc"
3929                 int ss AU = op[0] & 0x03;
3930 #line 392 "rx-decode.opc"
3931                 int rsrc AU = (op[1] >> 4) & 0x0f;
3932 #line 392 "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 392 "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 410 "rx-decode.opc"
3987                 int ss AU = op[0] & 0x03;
3988 #line 410 "rx-decode.opc"
3989                 int rsrc AU = (op[1] >> 4) & 0x0f;
3990 #line 410 "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 410 "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 331 "rx-decode.opc"
4045                 int s AU = (op[0] >> 2) & 0x01;
4046 #line 331 "rx-decode.opc"
4047                 int ss AU = op[0] & 0x03;
4048 #line 331 "rx-decode.opc"
4049                 int rsrc AU = (op[1] >> 4) & 0x0f;
4050 #line 331 "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 331 "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 512 "rx-decode.opc"
4141                 int immm AU = (op[1] >> 4) & 0x0f;
4142 #line 512 "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 512 "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 494 "rx-decode.opc"
4168                 int immm AU = (op[1] >> 4) & 0x0f;
4169 #line 494 "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 494 "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 476 "rx-decode.opc"
4195                 int immm AU = (op[1] >> 4) & 0x0f;
4196 #line 476 "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 476 "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 578 "rx-decode.opc"
4222                 int immm AU = (op[1] >> 4) & 0x0f;
4223 #line 578 "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 578 "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 386 "rx-decode.opc"
4249                 int immm AU = (op[1] >> 4) & 0x0f;
4250 #line 386 "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 386 "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 404 "rx-decode.opc"
4276                 int immm AU = (op[1] >> 4) & 0x0f;
4277 #line 404 "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 404 "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 280 "rx-decode.opc"
4303                 int immm AU = (op[1] >> 4) & 0x0f;
4304 #line 280 "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 280 "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 377 "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 664 "rx-decode.opc"
4346                 int i AU = op[0] & 0x01;
4347 #line 664 "rx-decode.opc"
4348                 int mmmm AU = (op[1] >> 4) & 0x0f;
4349 #line 664 "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 664 "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 654 "rx-decode.opc"
4386                 int i AU = op[0] & 0x01;
4387 #line 654 "rx-decode.opc"
4388                 int mmmm AU = (op[1] >> 4) & 0x0f;
4389 #line 654 "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 654 "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 644 "rx-decode.opc"
4426                 int i AU = op[0] & 0x01;
4427 #line 644 "rx-decode.opc"
4428                 int mmmm AU = (op[1] >> 4) & 0x0f;
4429 #line 644 "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 644 "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 344 "rx-decode.opc"
4465                 int dsta AU = (op[1] >> 4) & 0x0f;
4466 #line 344 "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 344 "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 341 "rx-decode.opc"
4492                 int dsta AU = (op[1] >> 4) & 0x0f;
4493 #line 341 "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 341 "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 485 "rx-decode.opc"
4520                 int im AU = op[0] & 0x03;
4521 #line 485 "rx-decode.opc"
4522                 int rsrc AU = (op[1] >> 4) & 0x0f;
4523 #line 485 "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 485 "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 497 "rx-decode.opc"
4578                 int im AU = op[0] & 0x03;
4579 #line 497 "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 497 "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 581 "rx-decode.opc"
4600                 int im AU = op[0] & 0x03;
4601 #line 581 "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 581 "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 389 "rx-decode.opc"
4622                 int im AU = op[0] & 0x03;
4623 #line 389 "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 389 "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 407 "rx-decode.opc"
4644                 int im AU = op[0] & 0x03;
4645 #line 407 "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 407 "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 500 "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 500 "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 961 "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 928 "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 928 "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 879 "rx-decode.opc"
4896                 int b AU = op[0] & 0x01;
4897 #line 879 "rx-decode.opc"
4898                 int ittt AU = (op[1] >> 4) & 0x0f;
4899 #line 879 "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 879 "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 889 "rx-decode.opc"
4937                 int b AU = op[0] & 0x01;
4938 #line 889 "rx-decode.opc"
4939                 int ittt AU = (op[1] >> 4) & 0x0f;
4940 #line 889 "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 889 "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 899 "rx-decode.opc"
4978                 int b AU = op[0] & 0x01;
4979 #line 899 "rx-decode.opc"
4980                 int ittt AU = (op[1] >> 4) & 0x0f;
4981 #line 899 "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 899 "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 434 "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 434 "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 455 "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 455 "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 537 "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 537 "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 819 "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 819 "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 679 "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 679 "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 676 "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 676 "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 350 "rx-decode.opc"
5128                 int sz AU = (op[1] >> 4) & 0x03;
5129 #line 350 "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 350 "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 347 "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 347 "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 934 "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 934 "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 931 "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 931 "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 729 "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 729 "rx-decode.opc"
5237                 ID(branch); 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 732 "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 732 "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 725 "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 725 "rx-decode.opc"
5303                 ID(branchrel); 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 741 "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 741 "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 765 "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 765 "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 756 "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 768 "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 768 "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 759 "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 774 "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 774 "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 762 "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 780 "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 780 "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 771 "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 822 "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 949 "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 952 "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 964 "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 925 "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 925 "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 922 "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 922 "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 308 "rx-decode.opc"
5631                 int sz AU = (op[0] >> 4) & 0x03;
5632 #line 308 "rx-decode.opc"
5633                 int dsp AU = op[0] & 0x07;
5634 #line 308 "rx-decode.opc"
5635                 int a AU = (op[1] >> 7) & 0x01;
5636 #line 308 "rx-decode.opc"
5637                 int dst AU = (op[1] >> 4) & 0x07;
5638 #line 308 "rx-decode.opc"
5639                 int b AU = (op[1] >> 3) & 0x01;
5640 #line 308 "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 308 "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 305 "rx-decode.opc"
5734                 int sz AU = (op[0] >> 4) & 0x03;
5735 #line 305 "rx-decode.opc"
5736                 int dsp AU = op[0] & 0x07;
5737 #line 305 "rx-decode.opc"
5738                 int a AU = (op[1] >> 7) & 0x01;
5739 #line 305 "rx-decode.opc"
5740                 int src AU = (op[1] >> 4) & 0x07;
5741 #line 305 "rx-decode.opc"
5742                 int b AU = (op[1] >> 3) & 0x01;
5743 #line 305 "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 305 "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 328 "rx-decode.opc"
6125                 int w AU = (op[0] >> 3) & 0x01;
6126 #line 328 "rx-decode.opc"
6127                 int dsp AU = op[0] & 0x07;
6128 #line 328 "rx-decode.opc"
6129                 int a AU = (op[1] >> 7) & 0x01;
6130 #line 328 "rx-decode.opc"
6131                 int src AU = (op[1] >> 4) & 0x07;
6132 #line 328 "rx-decode.opc"
6133                 int b AU = (op[1] >> 3) & 0x01;
6134 #line 328 "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 328 "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 286 "rx-decode.opc"
6300                 int sz AU = (op[0] >> 4) & 0x03;
6301 #line 286 "rx-decode.opc"
6302                 int sd AU = (op[0] >> 2) & 0x03;
6303 #line 286 "rx-decode.opc"
6304                 int ss AU = op[0] & 0x03;
6305 #line 286 "rx-decode.opc"
6306                 int rsrc AU = (op[1] >> 4) & 0x0f;
6307 #line 286 "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 286 "rx-decode.opc"
6322                 if (ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
6323                   {
6324                     ID(nop2);
6325                     rx->syntax = "nop";
6326                   }
6327                 else
6328                   {
6329                     ID(mov); sBWL(sz); F_____;
6330                     if ((ss == 3) && (sd != 3))
6331                 {
6332                   SD(ss, rdst, sz); DD(sd, rsrc, sz);
6333                 }
6334                     else
6335                 {
6336                   SD(ss, rsrc, sz); DD(sd, rdst, sz);
6337                 }
6338                   }
6339
6340               }
6341             break;
6342         }
6343       break;
6344     case 0xc1:
6345         GETBYTE ();
6346         switch (op[1] & 0x00)
6347         {
6348           case 0x00:
6349             goto op_semantics_41;
6350             break;
6351         }
6352       break;
6353     case 0xc2:
6354         GETBYTE ();
6355         switch (op[1] & 0x00)
6356         {
6357           case 0x00:
6358             goto op_semantics_41;
6359             break;
6360         }
6361       break;
6362     case 0xc3:
6363         GETBYTE ();
6364         switch (op[1] & 0x00)
6365         {
6366           case 0x00:
6367             goto op_semantics_41;
6368             break;
6369         }
6370       break;
6371     case 0xc4:
6372         GETBYTE ();
6373         switch (op[1] & 0x00)
6374         {
6375           case 0x00:
6376             goto op_semantics_41;
6377             break;
6378         }
6379       break;
6380     case 0xc5:
6381         GETBYTE ();
6382         switch (op[1] & 0x00)
6383         {
6384           case 0x00:
6385             goto op_semantics_41;
6386             break;
6387         }
6388       break;
6389     case 0xc6:
6390         GETBYTE ();
6391         switch (op[1] & 0x00)
6392         {
6393           case 0x00:
6394             goto op_semantics_41;
6395             break;
6396         }
6397       break;
6398     case 0xc7:
6399         GETBYTE ();
6400         switch (op[1] & 0x00)
6401         {
6402           case 0x00:
6403             goto op_semantics_41;
6404             break;
6405         }
6406       break;
6407     case 0xc8:
6408         GETBYTE ();
6409         switch (op[1] & 0x00)
6410         {
6411           case 0x00:
6412             goto op_semantics_41;
6413             break;
6414         }
6415       break;
6416     case 0xc9:
6417         GETBYTE ();
6418         switch (op[1] & 0x00)
6419         {
6420           case 0x00:
6421             goto op_semantics_41;
6422             break;
6423         }
6424       break;
6425     case 0xca:
6426         GETBYTE ();
6427         switch (op[1] & 0x00)
6428         {
6429           case 0x00:
6430             goto op_semantics_41;
6431             break;
6432         }
6433       break;
6434     case 0xcb:
6435         GETBYTE ();
6436         switch (op[1] & 0x00)
6437         {
6438           case 0x00:
6439             goto op_semantics_41;
6440             break;
6441         }
6442       break;
6443     case 0xcc:
6444         GETBYTE ();
6445         switch (op[1] & 0x00)
6446         {
6447           case 0x00:
6448             goto op_semantics_41;
6449             break;
6450         }
6451       break;
6452     case 0xcd:
6453         GETBYTE ();
6454         switch (op[1] & 0x00)
6455         {
6456           case 0x00:
6457             goto op_semantics_41;
6458             break;
6459         }
6460       break;
6461     case 0xce:
6462         GETBYTE ();
6463         switch (op[1] & 0x00)
6464         {
6465           case 0x00:
6466             goto op_semantics_41;
6467             break;
6468         }
6469       break;
6470     case 0xcf:
6471         GETBYTE ();
6472         switch (op[1] & 0x00)
6473         {
6474           case 0x00:
6475             goto op_semantics_41;
6476             break;
6477         }
6478       break;
6479     case 0xd0:
6480         GETBYTE ();
6481         switch (op[1] & 0x00)
6482         {
6483           case 0x00:
6484             goto op_semantics_41;
6485             break;
6486         }
6487       break;
6488     case 0xd1:
6489         GETBYTE ();
6490         switch (op[1] & 0x00)
6491         {
6492           case 0x00:
6493             goto op_semantics_41;
6494             break;
6495         }
6496       break;
6497     case 0xd2:
6498         GETBYTE ();
6499         switch (op[1] & 0x00)
6500         {
6501           case 0x00:
6502             goto op_semantics_41;
6503             break;
6504         }
6505       break;
6506     case 0xd3:
6507         GETBYTE ();
6508         switch (op[1] & 0x00)
6509         {
6510           case 0x00:
6511             goto op_semantics_41;
6512             break;
6513         }
6514       break;
6515     case 0xd4:
6516         GETBYTE ();
6517         switch (op[1] & 0x00)
6518         {
6519           case 0x00:
6520             goto op_semantics_41;
6521             break;
6522         }
6523       break;
6524     case 0xd5:
6525         GETBYTE ();
6526         switch (op[1] & 0x00)
6527         {
6528           case 0x00:
6529             goto op_semantics_41;
6530             break;
6531         }
6532       break;
6533     case 0xd6:
6534         GETBYTE ();
6535         switch (op[1] & 0x00)
6536         {
6537           case 0x00:
6538             goto op_semantics_41;
6539             break;
6540         }
6541       break;
6542     case 0xd7:
6543         GETBYTE ();
6544         switch (op[1] & 0x00)
6545         {
6546           case 0x00:
6547             goto op_semantics_41;
6548             break;
6549         }
6550       break;
6551     case 0xd8:
6552         GETBYTE ();
6553         switch (op[1] & 0x00)
6554         {
6555           case 0x00:
6556             goto op_semantics_41;
6557             break;
6558         }
6559       break;
6560     case 0xd9:
6561         GETBYTE ();
6562         switch (op[1] & 0x00)
6563         {
6564           case 0x00:
6565             goto op_semantics_41;
6566             break;
6567         }
6568       break;
6569     case 0xda:
6570         GETBYTE ();
6571         switch (op[1] & 0x00)
6572         {
6573           case 0x00:
6574             goto op_semantics_41;
6575             break;
6576         }
6577       break;
6578     case 0xdb:
6579         GETBYTE ();
6580         switch (op[1] & 0x00)
6581         {
6582           case 0x00:
6583             goto op_semantics_41;
6584             break;
6585         }
6586       break;
6587     case 0xdc:
6588         GETBYTE ();
6589         switch (op[1] & 0x00)
6590         {
6591           case 0x00:
6592             goto op_semantics_41;
6593             break;
6594         }
6595       break;
6596     case 0xdd:
6597         GETBYTE ();
6598         switch (op[1] & 0x00)
6599         {
6600           case 0x00:
6601             goto op_semantics_41;
6602             break;
6603         }
6604       break;
6605     case 0xde:
6606         GETBYTE ();
6607         switch (op[1] & 0x00)
6608         {
6609           case 0x00:
6610             goto op_semantics_41;
6611             break;
6612         }
6613       break;
6614     case 0xdf:
6615         GETBYTE ();
6616         switch (op[1] & 0x00)
6617         {
6618           case 0x00:
6619             goto op_semantics_41;
6620             break;
6621         }
6622       break;
6623     case 0xe0:
6624         GETBYTE ();
6625         switch (op[1] & 0x00)
6626         {
6627           case 0x00:
6628             goto op_semantics_41;
6629             break;
6630         }
6631       break;
6632     case 0xe1:
6633         GETBYTE ();
6634         switch (op[1] & 0x00)
6635         {
6636           case 0x00:
6637             goto op_semantics_41;
6638             break;
6639         }
6640       break;
6641     case 0xe2:
6642         GETBYTE ();
6643         switch (op[1] & 0x00)
6644         {
6645           case 0x00:
6646             goto op_semantics_41;
6647             break;
6648         }
6649       break;
6650     case 0xe3:
6651         GETBYTE ();
6652         switch (op[1] & 0x00)
6653         {
6654           case 0x00:
6655             goto op_semantics_41;
6656             break;
6657         }
6658       break;
6659     case 0xe4:
6660         GETBYTE ();
6661         switch (op[1] & 0x00)
6662         {
6663           case 0x00:
6664             goto op_semantics_41;
6665             break;
6666         }
6667       break;
6668     case 0xe5:
6669         GETBYTE ();
6670         switch (op[1] & 0x00)
6671         {
6672           case 0x00:
6673             goto op_semantics_41;
6674             break;
6675         }
6676       break;
6677     case 0xe6:
6678         GETBYTE ();
6679         switch (op[1] & 0x00)
6680         {
6681           case 0x00:
6682             goto op_semantics_41;
6683             break;
6684         }
6685       break;
6686     case 0xe7:
6687         GETBYTE ();
6688         switch (op[1] & 0x00)
6689         {
6690           case 0x00:
6691             goto op_semantics_41;
6692             break;
6693         }
6694       break;
6695     case 0xe8:
6696         GETBYTE ();
6697         switch (op[1] & 0x00)
6698         {
6699           case 0x00:
6700             goto op_semantics_41;
6701             break;
6702         }
6703       break;
6704     case 0xe9:
6705         GETBYTE ();
6706         switch (op[1] & 0x00)
6707         {
6708           case 0x00:
6709             goto op_semantics_41;
6710             break;
6711         }
6712       break;
6713     case 0xea:
6714         GETBYTE ();
6715         switch (op[1] & 0x00)
6716         {
6717           case 0x00:
6718             goto op_semantics_41;
6719             break;
6720         }
6721       break;
6722     case 0xeb:
6723         GETBYTE ();
6724         switch (op[1] & 0x00)
6725         {
6726           case 0x00:
6727             goto op_semantics_41;
6728             break;
6729         }
6730       break;
6731     case 0xec:
6732         GETBYTE ();
6733         switch (op[1] & 0x00)
6734         {
6735           case 0x00:
6736             goto op_semantics_41;
6737             break;
6738         }
6739       break;
6740     case 0xed:
6741         GETBYTE ();
6742         switch (op[1] & 0x00)
6743         {
6744           case 0x00:
6745             goto op_semantics_41;
6746             break;
6747         }
6748       break;
6749     case 0xee:
6750         GETBYTE ();
6751         switch (op[1] & 0x00)
6752         {
6753           case 0x00:
6754             goto op_semantics_41;
6755             break;
6756         }
6757       break;
6758     case 0xef:
6759         GETBYTE ();
6760         switch (op[1] & 0x00)
6761         {
6762           case 0x00:
6763             goto op_semantics_41;
6764             break;
6765         }
6766       break;
6767     case 0xf0:
6768         GETBYTE ();
6769         switch (op[1] & 0x08)
6770         {
6771           case 0x00:
6772             op_semantics_42:
6773               {
6774                 /** 1111 00sd rdst 0bit                 bset    #%1, %0%S0 */
6775 #line 873 "rx-decode.opc"
6776                 int sd AU = op[0] & 0x03;
6777 #line 873 "rx-decode.opc"
6778                 int rdst AU = (op[1] >> 4) & 0x0f;
6779 #line 873 "rx-decode.opc"
6780                 int bit AU = op[1] & 0x07;
6781                 if (trace)
6782                   {
6783                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6784                            "/** 1111 00sd rdst 0bit                     bset    #%1, %0%S0 */",
6785                            op[0], op[1]);
6786                     printf ("  sd = 0x%x,", sd);
6787                     printf ("  rdst = 0x%x,", rdst);
6788                     printf ("  bit = 0x%x\n", bit);
6789                   }
6790                 SYNTAX("bset    #%1, %0%S0");
6791 #line 873 "rx-decode.opc"
6792                 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
6793
6794               }
6795             break;
6796           case 0x08:
6797             op_semantics_43:
6798               {
6799                 /** 1111 00sd rdst 1bit                 bclr    #%1, %0%S0 */
6800 #line 883 "rx-decode.opc"
6801                 int sd AU = op[0] & 0x03;
6802 #line 883 "rx-decode.opc"
6803                 int rdst AU = (op[1] >> 4) & 0x0f;
6804 #line 883 "rx-decode.opc"
6805                 int bit AU = op[1] & 0x07;
6806                 if (trace)
6807                   {
6808                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6809                            "/** 1111 00sd rdst 1bit                     bclr    #%1, %0%S0 */",
6810                            op[0], op[1]);
6811                     printf ("  sd = 0x%x,", sd);
6812                     printf ("  rdst = 0x%x,", rdst);
6813                     printf ("  bit = 0x%x\n", bit);
6814                   }
6815                 SYNTAX("bclr    #%1, %0%S0");
6816 #line 883 "rx-decode.opc"
6817                 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
6818
6819               }
6820             break;
6821         }
6822       break;
6823     case 0xf1:
6824         GETBYTE ();
6825         switch (op[1] & 0x08)
6826         {
6827           case 0x00:
6828             goto op_semantics_42;
6829             break;
6830           case 0x08:
6831             goto op_semantics_43;
6832             break;
6833         }
6834       break;
6835     case 0xf2:
6836         GETBYTE ();
6837         switch (op[1] & 0x08)
6838         {
6839           case 0x00:
6840             goto op_semantics_42;
6841             break;
6842           case 0x08:
6843             goto op_semantics_43;
6844             break;
6845         }
6846       break;
6847     case 0xf3:
6848         GETBYTE ();
6849         switch (op[1] & 0x08)
6850         {
6851           case 0x00:
6852             goto op_semantics_42;
6853             break;
6854           case 0x08:
6855             goto op_semantics_43;
6856             break;
6857         }
6858       break;
6859     case 0xf4:
6860         GETBYTE ();
6861         switch (op[1] & 0x0c)
6862         {
6863           case 0x00:
6864           case 0x04:
6865             op_semantics_44:
6866               {
6867                 /** 1111 01sd rdst 0bit                 btst    #%2, %1%S1 */
6868 #line 893 "rx-decode.opc"
6869                 int sd AU = op[0] & 0x03;
6870 #line 893 "rx-decode.opc"
6871                 int rdst AU = (op[1] >> 4) & 0x0f;
6872 #line 893 "rx-decode.opc"
6873                 int bit AU = op[1] & 0x07;
6874                 if (trace)
6875                   {
6876                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6877                            "/** 1111 01sd rdst 0bit                     btst    #%2, %1%S1 */",
6878                            op[0], op[1]);
6879                     printf ("  sd = 0x%x,", sd);
6880                     printf ("  rdst = 0x%x,", rdst);
6881                     printf ("  bit = 0x%x\n", bit);
6882                   }
6883                 SYNTAX("btst    #%2, %1%S1");
6884 #line 893 "rx-decode.opc"
6885                 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
6886
6887               }
6888             break;
6889           case 0x08:
6890             op_semantics_45:
6891               {
6892                 /** 1111 01ss rsrc 10sz         push%s  %1 */
6893 #line 353 "rx-decode.opc"
6894                 int ss AU = op[0] & 0x03;
6895 #line 353 "rx-decode.opc"
6896                 int rsrc AU = (op[1] >> 4) & 0x0f;
6897 #line 353 "rx-decode.opc"
6898                 int sz AU = op[1] & 0x03;
6899                 if (trace)
6900                   {
6901                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6902                            "/** 1111 01ss rsrc 10sz             push%s  %1 */",
6903                            op[0], op[1]);
6904                     printf ("  ss = 0x%x,", ss);
6905                     printf ("  rsrc = 0x%x,", rsrc);
6906                     printf ("  sz = 0x%x\n", sz);
6907                   }
6908                 SYNTAX("push%s  %1");
6909 #line 353 "rx-decode.opc"
6910                 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
6911
6912               /*----------------------------------------------------------------------*/
6913               /* XCHG                                                                   */
6914
6915               }
6916             break;
6917           default: UNSUPPORTED(); break;
6918         }
6919       break;
6920     case 0xf5:
6921         GETBYTE ();
6922         switch (op[1] & 0x0c)
6923         {
6924           case 0x00:
6925           case 0x04:
6926             goto op_semantics_44;
6927             break;
6928           case 0x08:
6929             goto op_semantics_45;
6930             break;
6931           default: UNSUPPORTED(); break;
6932         }
6933       break;
6934     case 0xf6:
6935         GETBYTE ();
6936         switch (op[1] & 0x0c)
6937         {
6938           case 0x00:
6939           case 0x04:
6940             goto op_semantics_44;
6941             break;
6942           case 0x08:
6943             goto op_semantics_45;
6944             break;
6945           default: UNSUPPORTED(); break;
6946         }
6947       break;
6948     case 0xf7:
6949         GETBYTE ();
6950         switch (op[1] & 0x0c)
6951         {
6952           case 0x00:
6953           case 0x04:
6954             goto op_semantics_44;
6955             break;
6956           case 0x08:
6957             goto op_semantics_45;
6958             break;
6959           default: UNSUPPORTED(); break;
6960         }
6961       break;
6962     case 0xf8:
6963         GETBYTE ();
6964         switch (op[1] & 0x00)
6965         {
6966           case 0x00:
6967             op_semantics_46:
6968               {
6969                 /** 1111 10sd rdst im sz        mov%s   #%1, %0 */
6970 #line 264 "rx-decode.opc"
6971                 int sd AU = op[0] & 0x03;
6972 #line 264 "rx-decode.opc"
6973                 int rdst AU = (op[1] >> 4) & 0x0f;
6974 #line 264 "rx-decode.opc"
6975                 int im AU = (op[1] >> 2) & 0x03;
6976 #line 264 "rx-decode.opc"
6977                 int sz AU = op[1] & 0x03;
6978                 if (trace)
6979                   {
6980                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6981                            "/** 1111 10sd rdst im sz    mov%s   #%1, %0 */",
6982                            op[0], op[1]);
6983                     printf ("  sd = 0x%x,", sd);
6984                     printf ("  rdst = 0x%x,", rdst);
6985                     printf ("  im = 0x%x,", im);
6986                     printf ("  sz = 0x%x\n", sz);
6987                   }
6988                 SYNTAX("mov%s   #%1, %0");
6989 #line 264 "rx-decode.opc"
6990                 ID(mov); DD(sd, rdst, sz);
6991                 if ((im == 1 && sz == 0)
6992                     || (im == 2 && sz == 1)
6993                     || (im == 0 && sz == 2))
6994                   {
6995                     BWL (sz);
6996                     SC(IMM(im));
6997                   }
6998                 else
6999                   {
7000                     sBWL (sz);
7001                     SC(IMMex(im));
7002                   }
7003                  F_____;
7004
7005               }
7006             break;
7007         }
7008       break;
7009     case 0xf9:
7010         GETBYTE ();
7011         switch (op[1] & 0x00)
7012         {
7013           case 0x00:
7014             goto op_semantics_46;
7015             break;
7016         }
7017       break;
7018     case 0xfa:
7019         GETBYTE ();
7020         switch (op[1] & 0x00)
7021         {
7022           case 0x00:
7023             goto op_semantics_46;
7024             break;
7025         }
7026       break;
7027     case 0xfb:
7028         GETBYTE ();
7029         switch (op[1] & 0x00)
7030         {
7031           case 0x00:
7032             goto op_semantics_46;
7033             break;
7034         }
7035       break;
7036     case 0xfc:
7037         GETBYTE ();
7038         switch (op[1] & 0xff)
7039         {
7040           case 0x03:
7041               GETBYTE ();
7042               switch (op[2] & 0x00)
7043               {
7044                 case 0x00:
7045                     {
7046                       /** 1111 1100 0000 0011 rsrc rdst sbb     %1, %0 */
7047 #line 527 "rx-decode.opc"
7048                       int rsrc AU = (op[2] >> 4) & 0x0f;
7049 #line 527 "rx-decode.opc"
7050                       int rdst AU = op[2] & 0x0f;
7051                       if (trace)
7052                         {
7053                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7054                                  "/** 1111 1100 0000 0011 rsrc rdst     sbb     %1, %0 */",
7055                                  op[0], op[1], op[2]);
7056                           printf ("  rsrc = 0x%x,", rsrc);
7057                           printf ("  rdst = 0x%x\n", rdst);
7058                         }
7059                       SYNTAX("sbb       %1, %0");
7060 #line 527 "rx-decode.opc"
7061                       ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
7062
7063                       /* FIXME: only supports .L */
7064                     }
7065                   break;
7066               }
7067             break;
7068           case 0x07:
7069               GETBYTE ();
7070               switch (op[2] & 0x00)
7071               {
7072                 case 0x00:
7073                     {
7074                       /** 1111 1100 0000 0111 rsrc rdst neg     %2, %0 */
7075 #line 458 "rx-decode.opc"
7076                       int rsrc AU = (op[2] >> 4) & 0x0f;
7077 #line 458 "rx-decode.opc"
7078                       int rdst AU = op[2] & 0x0f;
7079                       if (trace)
7080                         {
7081                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7082                                  "/** 1111 1100 0000 0111 rsrc rdst     neg     %2, %0 */",
7083                                  op[0], op[1], op[2]);
7084                           printf ("  rsrc = 0x%x,", rsrc);
7085                           printf ("  rdst = 0x%x\n", rdst);
7086                         }
7087                       SYNTAX("neg       %2, %0");
7088 #line 458 "rx-decode.opc"
7089                       ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
7090
7091                     /*----------------------------------------------------------------------*/
7092                     /* ADC                                                                      */
7093
7094                     }
7095                   break;
7096               }
7097             break;
7098           case 0x0b:
7099               GETBYTE ();
7100               switch (op[2] & 0x00)
7101               {
7102                 case 0x00:
7103                     {
7104                       /** 1111 1100 0000 1011 rsrc rdst adc     %1, %0 */
7105 #line 467 "rx-decode.opc"
7106                       int rsrc AU = (op[2] >> 4) & 0x0f;
7107 #line 467 "rx-decode.opc"
7108                       int rdst AU = op[2] & 0x0f;
7109                       if (trace)
7110                         {
7111                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7112                                  "/** 1111 1100 0000 1011 rsrc rdst     adc     %1, %0 */",
7113                                  op[0], op[1], op[2]);
7114                           printf ("  rsrc = 0x%x,", rsrc);
7115                           printf ("  rdst = 0x%x\n", rdst);
7116                         }
7117                       SYNTAX("adc       %1, %0");
7118 #line 467 "rx-decode.opc"
7119                       ID(adc); SR(rsrc); DR(rdst); F_OSZC;
7120
7121                     }
7122                   break;
7123               }
7124             break;
7125           case 0x0f:
7126               GETBYTE ();
7127               switch (op[2] & 0x00)
7128               {
7129                 case 0x00:
7130                     {
7131                       /** 1111 1100 0000 1111 rsrc rdst abs     %1, %0 */
7132 #line 540 "rx-decode.opc"
7133                       int rsrc AU = (op[2] >> 4) & 0x0f;
7134 #line 540 "rx-decode.opc"
7135                       int rdst AU = op[2] & 0x0f;
7136                       if (trace)
7137                         {
7138                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7139                                  "/** 1111 1100 0000 1111 rsrc rdst     abs     %1, %0 */",
7140                                  op[0], op[1], op[2]);
7141                           printf ("  rsrc = 0x%x,", rsrc);
7142                           printf ("  rdst = 0x%x\n", rdst);
7143                         }
7144                       SYNTAX("abs       %1, %0");
7145 #line 540 "rx-decode.opc"
7146                       ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
7147
7148                     /*----------------------------------------------------------------------*/
7149                     /* MAX                                                                      */
7150
7151                     }
7152                   break;
7153               }
7154             break;
7155           case 0x10:
7156               GETBYTE ();
7157               switch (op[2] & 0x00)
7158               {
7159                 case 0x00:
7160                   op_semantics_47:
7161                     {
7162                       /** 1111 1100 0001 00ss rsrc rdst max     %1%S1, %0 */
7163 #line 549 "rx-decode.opc"
7164                       int ss AU = op[1] & 0x03;
7165 #line 549 "rx-decode.opc"
7166                       int rsrc AU = (op[2] >> 4) & 0x0f;
7167 #line 549 "rx-decode.opc"
7168                       int rdst AU = op[2] & 0x0f;
7169                       if (trace)
7170                         {
7171                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7172                                  "/** 1111 1100 0001 00ss rsrc rdst     max     %1%S1, %0 */",
7173                                  op[0], op[1], op[2]);
7174                           printf ("  ss = 0x%x,", ss);
7175                           printf ("  rsrc = 0x%x,", rsrc);
7176                           printf ("  rdst = 0x%x\n", rdst);
7177                         }
7178                       SYNTAX("max       %1%S1, %0");
7179 #line 549 "rx-decode.opc"
7180                       if (ss == 3 && rsrc == 0 && rdst == 0)
7181                         {
7182                           ID(nop3);
7183                           rx->syntax = "nop";
7184                         }
7185                       else
7186                         {
7187                           ID(max); SP(ss, rsrc); DR(rdst);
7188                         }
7189
7190                     }
7191                   break;
7192               }
7193             break;
7194           case 0x11:
7195               GETBYTE ();
7196               switch (op[2] & 0x00)
7197               {
7198                 case 0x00:
7199                   goto op_semantics_47;
7200                   break;
7201               }
7202             break;
7203           case 0x12:
7204               GETBYTE ();
7205               switch (op[2] & 0x00)
7206               {
7207                 case 0x00:
7208                   goto op_semantics_47;
7209                   break;
7210               }
7211             break;
7212           case 0x13:
7213               GETBYTE ();
7214               switch (op[2] & 0x00)
7215               {
7216                 case 0x00:
7217                   goto op_semantics_47;
7218                   break;
7219               }
7220             break;
7221           case 0x14:
7222               GETBYTE ();
7223               switch (op[2] & 0x00)
7224               {
7225                 case 0x00:
7226                   op_semantics_48:
7227                     {
7228                       /** 1111 1100 0001 01ss rsrc rdst min     %1%S1, %0 */
7229 #line 569 "rx-decode.opc"
7230                       int ss AU = op[1] & 0x03;
7231 #line 569 "rx-decode.opc"
7232                       int rsrc AU = (op[2] >> 4) & 0x0f;
7233 #line 569 "rx-decode.opc"
7234                       int rdst AU = op[2] & 0x0f;
7235                       if (trace)
7236                         {
7237                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7238                                  "/** 1111 1100 0001 01ss rsrc rdst     min     %1%S1, %0 */",
7239                                  op[0], op[1], op[2]);
7240                           printf ("  ss = 0x%x,", ss);
7241                           printf ("  rsrc = 0x%x,", rsrc);
7242                           printf ("  rdst = 0x%x\n", rdst);
7243                         }
7244                       SYNTAX("min       %1%S1, %0");
7245 #line 569 "rx-decode.opc"
7246                       ID(min); SP(ss, rsrc); DR(rdst);
7247
7248                     }
7249                   break;
7250               }
7251             break;
7252           case 0x15:
7253               GETBYTE ();
7254               switch (op[2] & 0x00)
7255               {
7256                 case 0x00:
7257                   goto op_semantics_48;
7258                   break;
7259               }
7260             break;
7261           case 0x16:
7262               GETBYTE ();
7263               switch (op[2] & 0x00)
7264               {
7265                 case 0x00:
7266                   goto op_semantics_48;
7267                   break;
7268               }
7269             break;
7270           case 0x17:
7271               GETBYTE ();
7272               switch (op[2] & 0x00)
7273               {
7274                 case 0x00:
7275                   goto op_semantics_48;
7276                   break;
7277               }
7278             break;
7279           case 0x18:
7280               GETBYTE ();
7281               switch (op[2] & 0x00)
7282               {
7283                 case 0x00:
7284                   op_semantics_49:
7285                     {
7286                       /** 1111 1100 0001 10ss rsrc rdst emul    %1%S1, %0 */
7287 #line 599 "rx-decode.opc"
7288                       int ss AU = op[1] & 0x03;
7289 #line 599 "rx-decode.opc"
7290                       int rsrc AU = (op[2] >> 4) & 0x0f;
7291 #line 599 "rx-decode.opc"
7292                       int rdst AU = op[2] & 0x0f;
7293                       if (trace)
7294                         {
7295                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7296                                  "/** 1111 1100 0001 10ss rsrc rdst     emul    %1%S1, %0 */",
7297                                  op[0], op[1], op[2]);
7298                           printf ("  ss = 0x%x,", ss);
7299                           printf ("  rsrc = 0x%x,", rsrc);
7300                           printf ("  rdst = 0x%x\n", rdst);
7301                         }
7302                       SYNTAX("emul      %1%S1, %0");
7303 #line 599 "rx-decode.opc"
7304                       ID(emul); SP(ss, rsrc); DR(rdst);
7305
7306                     }
7307                   break;
7308               }
7309             break;
7310           case 0x19:
7311               GETBYTE ();
7312               switch (op[2] & 0x00)
7313               {
7314                 case 0x00:
7315                   goto op_semantics_49;
7316                   break;
7317               }
7318             break;
7319           case 0x1a:
7320               GETBYTE ();
7321               switch (op[2] & 0x00)
7322               {
7323                 case 0x00:
7324                   goto op_semantics_49;
7325                   break;
7326               }
7327             break;
7328           case 0x1b:
7329               GETBYTE ();
7330               switch (op[2] & 0x00)
7331               {
7332                 case 0x00:
7333                   goto op_semantics_49;
7334                   break;
7335               }
7336             break;
7337           case 0x1c:
7338               GETBYTE ();
7339               switch (op[2] & 0x00)
7340               {
7341                 case 0x00:
7342                   op_semantics_50:
7343                     {
7344                       /** 1111 1100 0001 11ss rsrc rdst emulu   %1%S1, %0 */
7345 #line 611 "rx-decode.opc"
7346                       int ss AU = op[1] & 0x03;
7347 #line 611 "rx-decode.opc"
7348                       int rsrc AU = (op[2] >> 4) & 0x0f;
7349 #line 611 "rx-decode.opc"
7350                       int rdst AU = op[2] & 0x0f;
7351                       if (trace)
7352                         {
7353                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7354                                  "/** 1111 1100 0001 11ss rsrc rdst     emulu   %1%S1, %0 */",
7355                                  op[0], op[1], op[2]);
7356                           printf ("  ss = 0x%x,", ss);
7357                           printf ("  rsrc = 0x%x,", rsrc);
7358                           printf ("  rdst = 0x%x\n", rdst);
7359                         }
7360                       SYNTAX("emulu     %1%S1, %0");
7361 #line 611 "rx-decode.opc"
7362                       ID(emulu); SP(ss, rsrc); DR(rdst);
7363
7364                     }
7365                   break;
7366               }
7367             break;
7368           case 0x1d:
7369               GETBYTE ();
7370               switch (op[2] & 0x00)
7371               {
7372                 case 0x00:
7373                   goto op_semantics_50;
7374                   break;
7375               }
7376             break;
7377           case 0x1e:
7378               GETBYTE ();
7379               switch (op[2] & 0x00)
7380               {
7381                 case 0x00:
7382                   goto op_semantics_50;
7383                   break;
7384               }
7385             break;
7386           case 0x1f:
7387               GETBYTE ();
7388               switch (op[2] & 0x00)
7389               {
7390                 case 0x00:
7391                   goto op_semantics_50;
7392                   break;
7393               }
7394             break;
7395           case 0x20:
7396               GETBYTE ();
7397               switch (op[2] & 0x00)
7398               {
7399                 case 0x00:
7400                   op_semantics_51:
7401                     {
7402                       /** 1111 1100 0010 00ss rsrc rdst div     %1%S1, %0 */
7403 #line 623 "rx-decode.opc"
7404                       int ss AU = op[1] & 0x03;
7405 #line 623 "rx-decode.opc"
7406                       int rsrc AU = (op[2] >> 4) & 0x0f;
7407 #line 623 "rx-decode.opc"
7408                       int rdst AU = op[2] & 0x0f;
7409                       if (trace)
7410                         {
7411                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7412                                  "/** 1111 1100 0010 00ss rsrc rdst     div     %1%S1, %0 */",
7413                                  op[0], op[1], op[2]);
7414                           printf ("  ss = 0x%x,", ss);
7415                           printf ("  rsrc = 0x%x,", rsrc);
7416                           printf ("  rdst = 0x%x\n", rdst);
7417                         }
7418                       SYNTAX("div       %1%S1, %0");
7419 #line 623 "rx-decode.opc"
7420                       ID(div); SP(ss, rsrc); DR(rdst); F_O___;
7421
7422                     }
7423                   break;
7424               }
7425             break;
7426           case 0x21:
7427               GETBYTE ();
7428               switch (op[2] & 0x00)
7429               {
7430                 case 0x00:
7431                   goto op_semantics_51;
7432                   break;
7433               }
7434             break;
7435           case 0x22:
7436               GETBYTE ();
7437               switch (op[2] & 0x00)
7438               {
7439                 case 0x00:
7440                   goto op_semantics_51;
7441                   break;
7442               }
7443             break;
7444           case 0x23:
7445               GETBYTE ();
7446               switch (op[2] & 0x00)
7447               {
7448                 case 0x00:
7449                   goto op_semantics_51;
7450                   break;
7451               }
7452             break;
7453           case 0x24:
7454               GETBYTE ();
7455               switch (op[2] & 0x00)
7456               {
7457                 case 0x00:
7458                   op_semantics_52:
7459                     {
7460                       /** 1111 1100 0010 01ss rsrc rdst divu    %1%S1, %0 */
7461 #line 635 "rx-decode.opc"
7462                       int ss AU = op[1] & 0x03;
7463 #line 635 "rx-decode.opc"
7464                       int rsrc AU = (op[2] >> 4) & 0x0f;
7465 #line 635 "rx-decode.opc"
7466                       int rdst AU = op[2] & 0x0f;
7467                       if (trace)
7468                         {
7469                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7470                                  "/** 1111 1100 0010 01ss rsrc rdst     divu    %1%S1, %0 */",
7471                                  op[0], op[1], op[2]);
7472                           printf ("  ss = 0x%x,", ss);
7473                           printf ("  rsrc = 0x%x,", rsrc);
7474                           printf ("  rdst = 0x%x\n", rdst);
7475                         }
7476                       SYNTAX("divu      %1%S1, %0");
7477 #line 635 "rx-decode.opc"
7478                       ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
7479
7480                     }
7481                   break;
7482               }
7483             break;
7484           case 0x25:
7485               GETBYTE ();
7486               switch (op[2] & 0x00)
7487               {
7488                 case 0x00:
7489                   goto op_semantics_52;
7490                   break;
7491               }
7492             break;
7493           case 0x26:
7494               GETBYTE ();
7495               switch (op[2] & 0x00)
7496               {
7497                 case 0x00:
7498                   goto op_semantics_52;
7499                   break;
7500               }
7501             break;
7502           case 0x27:
7503               GETBYTE ();
7504               switch (op[2] & 0x00)
7505               {
7506                 case 0x00:
7507                   goto op_semantics_52;
7508                   break;
7509               }
7510             break;
7511           case 0x30:
7512               GETBYTE ();
7513               switch (op[2] & 0x00)
7514               {
7515                 case 0x00:
7516                   op_semantics_53:
7517                     {
7518                       /** 1111 1100 0011 00ss rsrc rdst tst     %1%S1, %2 */
7519 #line 446 "rx-decode.opc"
7520                       int ss AU = op[1] & 0x03;
7521 #line 446 "rx-decode.opc"
7522                       int rsrc AU = (op[2] >> 4) & 0x0f;
7523 #line 446 "rx-decode.opc"
7524                       int rdst AU = op[2] & 0x0f;
7525                       if (trace)
7526                         {
7527                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7528                                  "/** 1111 1100 0011 00ss rsrc rdst     tst     %1%S1, %2 */",
7529                                  op[0], op[1], op[2]);
7530                           printf ("  ss = 0x%x,", ss);
7531                           printf ("  rsrc = 0x%x,", rsrc);
7532                           printf ("  rdst = 0x%x\n", rdst);
7533                         }
7534                       SYNTAX("tst       %1%S1, %2");
7535 #line 446 "rx-decode.opc"
7536                       ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
7537
7538                     }
7539                   break;
7540               }
7541             break;
7542           case 0x31:
7543               GETBYTE ();
7544               switch (op[2] & 0x00)
7545               {
7546                 case 0x00:
7547                   goto op_semantics_53;
7548                   break;
7549               }
7550             break;
7551           case 0x32:
7552               GETBYTE ();
7553               switch (op[2] & 0x00)
7554               {
7555                 case 0x00:
7556                   goto op_semantics_53;
7557                   break;
7558               }
7559             break;
7560           case 0x33:
7561               GETBYTE ();
7562               switch (op[2] & 0x00)
7563               {
7564                 case 0x00:
7565                   goto op_semantics_53;
7566                   break;
7567               }
7568             break;
7569           case 0x34:
7570               GETBYTE ();
7571               switch (op[2] & 0x00)
7572               {
7573                 case 0x00:
7574                   op_semantics_54:
7575                     {
7576                       /** 1111 1100 0011 01ss rsrc rdst xor     %1%S1, %0 */
7577 #line 425 "rx-decode.opc"
7578                       int ss AU = op[1] & 0x03;
7579 #line 425 "rx-decode.opc"
7580                       int rsrc AU = (op[2] >> 4) & 0x0f;
7581 #line 425 "rx-decode.opc"
7582                       int rdst AU = op[2] & 0x0f;
7583                       if (trace)
7584                         {
7585                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7586                                  "/** 1111 1100 0011 01ss rsrc rdst     xor     %1%S1, %0 */",
7587                                  op[0], op[1], op[2]);
7588                           printf ("  ss = 0x%x,", ss);
7589                           printf ("  rsrc = 0x%x,", rsrc);
7590                           printf ("  rdst = 0x%x\n", rdst);
7591                         }
7592                       SYNTAX("xor       %1%S1, %0");
7593 #line 425 "rx-decode.opc"
7594                       ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
7595
7596                     }
7597                   break;
7598               }
7599             break;
7600           case 0x35:
7601               GETBYTE ();
7602               switch (op[2] & 0x00)
7603               {
7604                 case 0x00:
7605                   goto op_semantics_54;
7606                   break;
7607               }
7608             break;
7609           case 0x36:
7610               GETBYTE ();
7611               switch (op[2] & 0x00)
7612               {
7613                 case 0x00:
7614                   goto op_semantics_54;
7615                   break;
7616               }
7617             break;
7618           case 0x37:
7619               GETBYTE ();
7620               switch (op[2] & 0x00)
7621               {
7622                 case 0x00:
7623                   goto op_semantics_54;
7624                   break;
7625               }
7626             break;
7627           case 0x3b:
7628               GETBYTE ();
7629               switch (op[2] & 0x00)
7630               {
7631                 case 0x00:
7632                     {
7633                       /** 1111 1100 0011 1011 rsrc rdst not     %1, %0 */
7634 #line 437 "rx-decode.opc"
7635                       int rsrc AU = (op[2] >> 4) & 0x0f;
7636 #line 437 "rx-decode.opc"
7637                       int rdst AU = op[2] & 0x0f;
7638                       if (trace)
7639                         {
7640                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7641                                  "/** 1111 1100 0011 1011 rsrc rdst     not     %1, %0 */",
7642                                  op[0], op[1], op[2]);
7643                           printf ("  rsrc = 0x%x,", rsrc);
7644                           printf ("  rdst = 0x%x\n", rdst);
7645                         }
7646                       SYNTAX("not       %1, %0");
7647 #line 437 "rx-decode.opc"
7648                       ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
7649
7650                     /*----------------------------------------------------------------------*/
7651                     /* TST                                                                      */
7652
7653                     }
7654                   break;
7655               }
7656             break;
7657           case 0x40:
7658               GETBYTE ();
7659               switch (op[2] & 0x00)
7660               {
7661                 case 0x00:
7662                   op_semantics_55:
7663                     {
7664                       /** 1111 1100 0100 00ss rsrc rdst xchg    %1%S1, %0 */
7665 #line 359 "rx-decode.opc"
7666                       int ss AU = op[1] & 0x03;
7667 #line 359 "rx-decode.opc"
7668                       int rsrc AU = (op[2] >> 4) & 0x0f;
7669 #line 359 "rx-decode.opc"
7670                       int rdst AU = op[2] & 0x0f;
7671                       if (trace)
7672                         {
7673                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7674                                  "/** 1111 1100 0100 00ss rsrc rdst     xchg    %1%S1, %0 */",
7675                                  op[0], op[1], op[2]);
7676                           printf ("  ss = 0x%x,", ss);
7677                           printf ("  rsrc = 0x%x,", rsrc);
7678                           printf ("  rdst = 0x%x\n", rdst);
7679                         }
7680                       SYNTAX("xchg      %1%S1, %0");
7681 #line 359 "rx-decode.opc"
7682                       ID(xchg); DR(rdst); SP(ss, rsrc);
7683
7684                     }
7685                   break;
7686               }
7687             break;
7688           case 0x41:
7689               GETBYTE ();
7690               switch (op[2] & 0x00)
7691               {
7692                 case 0x00:
7693                   goto op_semantics_55;
7694                   break;
7695               }
7696             break;
7697           case 0x42:
7698               GETBYTE ();
7699               switch (op[2] & 0x00)
7700               {
7701                 case 0x00:
7702                   goto op_semantics_55;
7703                   break;
7704               }
7705             break;
7706           case 0x43:
7707               GETBYTE ();
7708               switch (op[2] & 0x00)
7709               {
7710                 case 0x00:
7711                   goto op_semantics_55;
7712                   break;
7713               }
7714             break;
7715           case 0x44:
7716               GETBYTE ();
7717               switch (op[2] & 0x00)
7718               {
7719                 case 0x00:
7720                   op_semantics_56:
7721                     {
7722                       /** 1111 1100 0100 01sd rsrc rdst itof    %1%S1, %0 */
7723 #line 864 "rx-decode.opc"
7724                       int sd AU = op[1] & 0x03;
7725 #line 864 "rx-decode.opc"
7726                       int rsrc AU = (op[2] >> 4) & 0x0f;
7727 #line 864 "rx-decode.opc"
7728                       int rdst AU = op[2] & 0x0f;
7729                       if (trace)
7730                         {
7731                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7732                                  "/** 1111 1100 0100 01sd rsrc rdst     itof    %1%S1, %0 */",
7733                                  op[0], op[1], op[2]);
7734                           printf ("  sd = 0x%x,", sd);
7735                           printf ("  rsrc = 0x%x,", rsrc);
7736                           printf ("  rdst = 0x%x\n", rdst);
7737                         }
7738                       SYNTAX("itof      %1%S1, %0");
7739 #line 864 "rx-decode.opc"
7740                       ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
7741
7742                     }
7743                   break;
7744               }
7745             break;
7746           case 0x45:
7747               GETBYTE ();
7748               switch (op[2] & 0x00)
7749               {
7750                 case 0x00:
7751                   goto op_semantics_56;
7752                   break;
7753               }
7754             break;
7755           case 0x46:
7756               GETBYTE ();
7757               switch (op[2] & 0x00)
7758               {
7759                 case 0x00:
7760                   goto op_semantics_56;
7761                   break;
7762               }
7763             break;
7764           case 0x47:
7765               GETBYTE ();
7766               switch (op[2] & 0x00)
7767               {
7768                 case 0x00:
7769                   goto op_semantics_56;
7770                   break;
7771               }
7772             break;
7773           case 0x60:
7774               GETBYTE ();
7775               switch (op[2] & 0x00)
7776               {
7777                 case 0x00:
7778                   op_semantics_57:
7779                     {
7780                       /** 1111 1100 0110 00sd rdst rsrc bset    %1, %0%S0 */
7781 #line 876 "rx-decode.opc"
7782                       int sd AU = op[1] & 0x03;
7783 #line 876 "rx-decode.opc"
7784                       int rdst AU = (op[2] >> 4) & 0x0f;
7785 #line 876 "rx-decode.opc"
7786                       int rsrc AU = op[2] & 0x0f;
7787                       if (trace)
7788                         {
7789                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7790                                  "/** 1111 1100 0110 00sd rdst rsrc     bset    %1, %0%S0 */",
7791                                  op[0], op[1], op[2]);
7792                           printf ("  sd = 0x%x,", sd);
7793                           printf ("  rdst = 0x%x,", rdst);
7794                           printf ("  rsrc = 0x%x\n", rsrc);
7795                         }
7796                       SYNTAX("bset      %1, %0%S0");
7797 #line 876 "rx-decode.opc"
7798                       ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
7799
7800                     }
7801                   break;
7802               }
7803             break;
7804           case 0x61:
7805               GETBYTE ();
7806               switch (op[2] & 0x00)
7807               {
7808                 case 0x00:
7809                   goto op_semantics_57;
7810                   break;
7811               }
7812             break;
7813           case 0x62:
7814               GETBYTE ();
7815               switch (op[2] & 0x00)
7816               {
7817                 case 0x00:
7818                   goto op_semantics_57;
7819                   break;
7820               }
7821             break;
7822           case 0x63:
7823               GETBYTE ();
7824               switch (op[2] & 0x00)
7825               {
7826                 case 0x00:
7827                   goto op_semantics_57;
7828                   break;
7829               }
7830             break;
7831           case 0x64:
7832               GETBYTE ();
7833               switch (op[2] & 0x00)
7834               {
7835                 case 0x00:
7836                   op_semantics_58:
7837                     {
7838                       /** 1111 1100 0110 01sd rdst rsrc bclr    %1, %0%S0 */
7839 #line 886 "rx-decode.opc"
7840                       int sd AU = op[1] & 0x03;
7841 #line 886 "rx-decode.opc"
7842                       int rdst AU = (op[2] >> 4) & 0x0f;
7843 #line 886 "rx-decode.opc"
7844                       int rsrc AU = op[2] & 0x0f;
7845                       if (trace)
7846                         {
7847                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7848                                  "/** 1111 1100 0110 01sd rdst rsrc     bclr    %1, %0%S0 */",
7849                                  op[0], op[1], op[2]);
7850                           printf ("  sd = 0x%x,", sd);
7851                           printf ("  rdst = 0x%x,", rdst);
7852                           printf ("  rsrc = 0x%x\n", rsrc);
7853                         }
7854                       SYNTAX("bclr      %1, %0%S0");
7855 #line 886 "rx-decode.opc"
7856                       ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
7857
7858                     }
7859                   break;
7860               }
7861             break;
7862           case 0x65:
7863               GETBYTE ();
7864               switch (op[2] & 0x00)
7865               {
7866                 case 0x00:
7867                   goto op_semantics_58;
7868                   break;
7869               }
7870             break;
7871           case 0x66:
7872               GETBYTE ();
7873               switch (op[2] & 0x00)
7874               {
7875                 case 0x00:
7876                   goto op_semantics_58;
7877                   break;
7878               }
7879             break;
7880           case 0x67:
7881               GETBYTE ();
7882               switch (op[2] & 0x00)
7883               {
7884                 case 0x00:
7885                   goto op_semantics_58;
7886                   break;
7887               }
7888             break;
7889           case 0x68:
7890               GETBYTE ();
7891               switch (op[2] & 0x00)
7892               {
7893                 case 0x00:
7894                   op_semantics_59:
7895                     {
7896                       /** 1111 1100 0110 10sd rdst rsrc btst    %2, %1%S1 */
7897 #line 896 "rx-decode.opc"
7898                       int sd AU = op[1] & 0x03;
7899 #line 896 "rx-decode.opc"
7900                       int rdst AU = (op[2] >> 4) & 0x0f;
7901 #line 896 "rx-decode.opc"
7902                       int rsrc AU = op[2] & 0x0f;
7903                       if (trace)
7904                         {
7905                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7906                                  "/** 1111 1100 0110 10sd rdst rsrc     btst    %2, %1%S1 */",
7907                                  op[0], op[1], op[2]);
7908                           printf ("  sd = 0x%x,", sd);
7909                           printf ("  rdst = 0x%x,", rdst);
7910                           printf ("  rsrc = 0x%x\n", rsrc);
7911                         }
7912                       SYNTAX("btst      %2, %1%S1");
7913 #line 896 "rx-decode.opc"
7914                       ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
7915
7916                     }
7917                   break;
7918               }
7919             break;
7920           case 0x69:
7921               GETBYTE ();
7922               switch (op[2] & 0x00)
7923               {
7924                 case 0x00:
7925                   goto op_semantics_59;
7926                   break;
7927               }
7928             break;
7929           case 0x6a:
7930               GETBYTE ();
7931               switch (op[2] & 0x00)
7932               {
7933                 case 0x00:
7934                   goto op_semantics_59;
7935                   break;
7936               }
7937             break;
7938           case 0x6b:
7939               GETBYTE ();
7940               switch (op[2] & 0x00)
7941               {
7942                 case 0x00:
7943                   goto op_semantics_59;
7944                   break;
7945               }
7946             break;
7947           case 0x6c:
7948               GETBYTE ();
7949               switch (op[2] & 0x00)
7950               {
7951                 case 0x00:
7952                   op_semantics_60:
7953                     {
7954                       /** 1111 1100 0110 11sd rdst rsrc bnot    %1, %0%S0 */
7955 #line 906 "rx-decode.opc"
7956                       int sd AU = op[1] & 0x03;
7957 #line 906 "rx-decode.opc"
7958                       int rdst AU = (op[2] >> 4) & 0x0f;
7959 #line 906 "rx-decode.opc"
7960                       int rsrc AU = op[2] & 0x0f;
7961                       if (trace)
7962                         {
7963                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7964                                  "/** 1111 1100 0110 11sd rdst rsrc     bnot    %1, %0%S0 */",
7965                                  op[0], op[1], op[2]);
7966                           printf ("  sd = 0x%x,", sd);
7967                           printf ("  rdst = 0x%x,", rdst);
7968                           printf ("  rsrc = 0x%x\n", rsrc);
7969                         }
7970                       SYNTAX("bnot      %1, %0%S0");
7971 #line 906 "rx-decode.opc"
7972                       ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
7973
7974                     }
7975                   break;
7976               }
7977             break;
7978           case 0x6d:
7979               GETBYTE ();
7980               switch (op[2] & 0x00)
7981               {
7982                 case 0x00:
7983                   goto op_semantics_60;
7984                   break;
7985               }
7986             break;
7987           case 0x6e:
7988               GETBYTE ();
7989               switch (op[2] & 0x00)
7990               {
7991                 case 0x00:
7992                   goto op_semantics_60;
7993                   break;
7994               }
7995             break;
7996           case 0x6f:
7997               GETBYTE ();
7998               switch (op[2] & 0x00)
7999               {
8000                 case 0x00:
8001                   goto op_semantics_60;
8002                   break;
8003               }
8004             break;
8005           case 0x80:
8006               GETBYTE ();
8007               switch (op[2] & 0x00)
8008               {
8009                 case 0x00:
8010                   op_semantics_61:
8011                     {
8012                       /** 1111 1100 1000 00sd rsrc rdst fsub    %1%S1, %0 */
8013 #line 843 "rx-decode.opc"
8014                       int sd AU = op[1] & 0x03;
8015 #line 843 "rx-decode.opc"
8016                       int rsrc AU = (op[2] >> 4) & 0x0f;
8017 #line 843 "rx-decode.opc"
8018                       int rdst AU = op[2] & 0x0f;
8019                       if (trace)
8020                         {
8021                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8022                                  "/** 1111 1100 1000 00sd rsrc rdst     fsub    %1%S1, %0 */",
8023                                  op[0], op[1], op[2]);
8024                           printf ("  sd = 0x%x,", sd);
8025                           printf ("  rsrc = 0x%x,", rsrc);
8026                           printf ("  rdst = 0x%x\n", rdst);
8027                         }
8028                       SYNTAX("fsub      %1%S1, %0");
8029 #line 843 "rx-decode.opc"
8030                       ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8031
8032                     }
8033                   break;
8034               }
8035             break;
8036           case 0x81:
8037               GETBYTE ();
8038               switch (op[2] & 0x00)
8039               {
8040                 case 0x00:
8041                   goto op_semantics_61;
8042                   break;
8043               }
8044             break;
8045           case 0x82:
8046               GETBYTE ();
8047               switch (op[2] & 0x00)
8048               {
8049                 case 0x00:
8050                   goto op_semantics_61;
8051                   break;
8052               }
8053             break;
8054           case 0x83:
8055               GETBYTE ();
8056               switch (op[2] & 0x00)
8057               {
8058                 case 0x00:
8059                   goto op_semantics_61;
8060                   break;
8061               }
8062             break;
8063           case 0x84:
8064               GETBYTE ();
8065               switch (op[2] & 0x00)
8066               {
8067                 case 0x00:
8068                   op_semantics_62:
8069                     {
8070                       /** 1111 1100 1000 01sd rsrc rdst fcmp    %1%S1, %0 */
8071 #line 837 "rx-decode.opc"
8072                       int sd AU = op[1] & 0x03;
8073 #line 837 "rx-decode.opc"
8074                       int rsrc AU = (op[2] >> 4) & 0x0f;
8075 #line 837 "rx-decode.opc"
8076                       int rdst AU = op[2] & 0x0f;
8077                       if (trace)
8078                         {
8079                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8080                                  "/** 1111 1100 1000 01sd rsrc rdst     fcmp    %1%S1, %0 */",
8081                                  op[0], op[1], op[2]);
8082                           printf ("  sd = 0x%x,", sd);
8083                           printf ("  rsrc = 0x%x,", rsrc);
8084                           printf ("  rdst = 0x%x\n", rdst);
8085                         }
8086                       SYNTAX("fcmp      %1%S1, %0");
8087 #line 837 "rx-decode.opc"
8088                       ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
8089
8090                     }
8091                   break;
8092               }
8093             break;
8094           case 0x85:
8095               GETBYTE ();
8096               switch (op[2] & 0x00)
8097               {
8098                 case 0x00:
8099                   goto op_semantics_62;
8100                   break;
8101               }
8102             break;
8103           case 0x86:
8104               GETBYTE ();
8105               switch (op[2] & 0x00)
8106               {
8107                 case 0x00:
8108                   goto op_semantics_62;
8109                   break;
8110               }
8111             break;
8112           case 0x87:
8113               GETBYTE ();
8114               switch (op[2] & 0x00)
8115               {
8116                 case 0x00:
8117                   goto op_semantics_62;
8118                   break;
8119               }
8120             break;
8121           case 0x88:
8122               GETBYTE ();
8123               switch (op[2] & 0x00)
8124               {
8125                 case 0x00:
8126                   op_semantics_63:
8127                     {
8128                       /** 1111 1100 1000 10sd rsrc rdst fadd    %1%S1, %0 */
8129 #line 831 "rx-decode.opc"
8130                       int sd AU = op[1] & 0x03;
8131 #line 831 "rx-decode.opc"
8132                       int rsrc AU = (op[2] >> 4) & 0x0f;
8133 #line 831 "rx-decode.opc"
8134                       int rdst AU = op[2] & 0x0f;
8135                       if (trace)
8136                         {
8137                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8138                                  "/** 1111 1100 1000 10sd rsrc rdst     fadd    %1%S1, %0 */",
8139                                  op[0], op[1], op[2]);
8140                           printf ("  sd = 0x%x,", sd);
8141                           printf ("  rsrc = 0x%x,", rsrc);
8142                           printf ("  rdst = 0x%x\n", rdst);
8143                         }
8144                       SYNTAX("fadd      %1%S1, %0");
8145 #line 831 "rx-decode.opc"
8146                       ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8147
8148                     }
8149                   break;
8150               }
8151             break;
8152           case 0x89:
8153               GETBYTE ();
8154               switch (op[2] & 0x00)
8155               {
8156                 case 0x00:
8157                   goto op_semantics_63;
8158                   break;
8159               }
8160             break;
8161           case 0x8a:
8162               GETBYTE ();
8163               switch (op[2] & 0x00)
8164               {
8165                 case 0x00:
8166                   goto op_semantics_63;
8167                   break;
8168               }
8169             break;
8170           case 0x8b:
8171               GETBYTE ();
8172               switch (op[2] & 0x00)
8173               {
8174                 case 0x00:
8175                   goto op_semantics_63;
8176                   break;
8177               }
8178             break;
8179           case 0x8c:
8180               GETBYTE ();
8181               switch (op[2] & 0x00)
8182               {
8183                 case 0x00:
8184                   op_semantics_64:
8185                     {
8186                       /** 1111 1100 1000 11sd rsrc rdst fmul    %1%S1, %0 */
8187 #line 852 "rx-decode.opc"
8188                       int sd AU = op[1] & 0x03;
8189 #line 852 "rx-decode.opc"
8190                       int rsrc AU = (op[2] >> 4) & 0x0f;
8191 #line 852 "rx-decode.opc"
8192                       int rdst AU = op[2] & 0x0f;
8193                       if (trace)
8194                         {
8195                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8196                                  "/** 1111 1100 1000 11sd rsrc rdst     fmul    %1%S1, %0 */",
8197                                  op[0], op[1], op[2]);
8198                           printf ("  sd = 0x%x,", sd);
8199                           printf ("  rsrc = 0x%x,", rsrc);
8200                           printf ("  rdst = 0x%x\n", rdst);
8201                         }
8202                       SYNTAX("fmul      %1%S1, %0");
8203 #line 852 "rx-decode.opc"
8204                       ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8205
8206                     }
8207                   break;
8208               }
8209             break;
8210           case 0x8d:
8211               GETBYTE ();
8212               switch (op[2] & 0x00)
8213               {
8214                 case 0x00:
8215                   goto op_semantics_64;
8216                   break;
8217               }
8218             break;
8219           case 0x8e:
8220               GETBYTE ();
8221               switch (op[2] & 0x00)
8222               {
8223                 case 0x00:
8224                   goto op_semantics_64;
8225                   break;
8226               }
8227             break;
8228           case 0x8f:
8229               GETBYTE ();
8230               switch (op[2] & 0x00)
8231               {
8232                 case 0x00:
8233                   goto op_semantics_64;
8234                   break;
8235               }
8236             break;
8237           case 0x90:
8238               GETBYTE ();
8239               switch (op[2] & 0x00)
8240               {
8241                 case 0x00:
8242                   op_semantics_65:
8243                     {
8244                       /** 1111 1100 1001 00sd rsrc rdst fdiv    %1%S1, %0 */
8245 #line 858 "rx-decode.opc"
8246                       int sd AU = op[1] & 0x03;
8247 #line 858 "rx-decode.opc"
8248                       int rsrc AU = (op[2] >> 4) & 0x0f;
8249 #line 858 "rx-decode.opc"
8250                       int rdst AU = op[2] & 0x0f;
8251                       if (trace)
8252                         {
8253                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8254                                  "/** 1111 1100 1001 00sd rsrc rdst     fdiv    %1%S1, %0 */",
8255                                  op[0], op[1], op[2]);
8256                           printf ("  sd = 0x%x,", sd);
8257                           printf ("  rsrc = 0x%x,", rsrc);
8258                           printf ("  rdst = 0x%x\n", rdst);
8259                         }
8260                       SYNTAX("fdiv      %1%S1, %0");
8261 #line 858 "rx-decode.opc"
8262                       ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8263
8264                     }
8265                   break;
8266               }
8267             break;
8268           case 0x91:
8269               GETBYTE ();
8270               switch (op[2] & 0x00)
8271               {
8272                 case 0x00:
8273                   goto op_semantics_65;
8274                   break;
8275               }
8276             break;
8277           case 0x92:
8278               GETBYTE ();
8279               switch (op[2] & 0x00)
8280               {
8281                 case 0x00:
8282                   goto op_semantics_65;
8283                   break;
8284               }
8285             break;
8286           case 0x93:
8287               GETBYTE ();
8288               switch (op[2] & 0x00)
8289               {
8290                 case 0x00:
8291                   goto op_semantics_65;
8292                   break;
8293               }
8294             break;
8295           case 0x94:
8296               GETBYTE ();
8297               switch (op[2] & 0x00)
8298               {
8299                 case 0x00:
8300                   op_semantics_66:
8301                     {
8302                       /** 1111 1100 1001 01sd rsrc rdst ftoi    %1%S1, %0 */
8303 #line 846 "rx-decode.opc"
8304                       int sd AU = op[1] & 0x03;
8305 #line 846 "rx-decode.opc"
8306                       int rsrc AU = (op[2] >> 4) & 0x0f;
8307 #line 846 "rx-decode.opc"
8308                       int rdst AU = op[2] & 0x0f;
8309                       if (trace)
8310                         {
8311                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8312                                  "/** 1111 1100 1001 01sd rsrc rdst     ftoi    %1%S1, %0 */",
8313                                  op[0], op[1], op[2]);
8314                           printf ("  sd = 0x%x,", sd);
8315                           printf ("  rsrc = 0x%x,", rsrc);
8316                           printf ("  rdst = 0x%x\n", rdst);
8317                         }
8318                       SYNTAX("ftoi      %1%S1, %0");
8319 #line 846 "rx-decode.opc"
8320                       ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8321
8322                     }
8323                   break;
8324               }
8325             break;
8326           case 0x95:
8327               GETBYTE ();
8328               switch (op[2] & 0x00)
8329               {
8330                 case 0x00:
8331                   goto op_semantics_66;
8332                   break;
8333               }
8334             break;
8335           case 0x96:
8336               GETBYTE ();
8337               switch (op[2] & 0x00)
8338               {
8339                 case 0x00:
8340                   goto op_semantics_66;
8341                   break;
8342               }
8343             break;
8344           case 0x97:
8345               GETBYTE ();
8346               switch (op[2] & 0x00)
8347               {
8348                 case 0x00:
8349                   goto op_semantics_66;
8350                   break;
8351               }
8352             break;
8353           case 0x98:
8354               GETBYTE ();
8355               switch (op[2] & 0x00)
8356               {
8357                 case 0x00:
8358                   op_semantics_67:
8359                     {
8360                       /** 1111 1100 1001 10sd rsrc rdst round   %1%S1, %0 */
8361 #line 861 "rx-decode.opc"
8362                       int sd AU = op[1] & 0x03;
8363 #line 861 "rx-decode.opc"
8364                       int rsrc AU = (op[2] >> 4) & 0x0f;
8365 #line 861 "rx-decode.opc"
8366                       int rdst AU = op[2] & 0x0f;
8367                       if (trace)
8368                         {
8369                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8370                                  "/** 1111 1100 1001 10sd rsrc rdst     round   %1%S1, %0 */",
8371                                  op[0], op[1], op[2]);
8372                           printf ("  sd = 0x%x,", sd);
8373                           printf ("  rsrc = 0x%x,", rsrc);
8374                           printf ("  rdst = 0x%x\n", rdst);
8375                         }
8376                       SYNTAX("round     %1%S1, %0");
8377 #line 861 "rx-decode.opc"
8378                       ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8379
8380                     }
8381                   break;
8382               }
8383             break;
8384           case 0x99:
8385               GETBYTE ();
8386               switch (op[2] & 0x00)
8387               {
8388                 case 0x00:
8389                   goto op_semantics_67;
8390                   break;
8391               }
8392             break;
8393           case 0x9a:
8394               GETBYTE ();
8395               switch (op[2] & 0x00)
8396               {
8397                 case 0x00:
8398                   goto op_semantics_67;
8399                   break;
8400               }
8401             break;
8402           case 0x9b:
8403               GETBYTE ();
8404               switch (op[2] & 0x00)
8405               {
8406                 case 0x00:
8407                   goto op_semantics_67;
8408                   break;
8409               }
8410             break;
8411           case 0xd0:
8412               GETBYTE ();
8413               switch (op[2] & 0x00)
8414               {
8415                 case 0x00:
8416                   op_semantics_68:
8417                     {
8418                       /** 1111 1100 1101 sz sd rdst cond        sc%1%s  %0 */
8419 #line 970 "rx-decode.opc"
8420                       int sz AU = (op[1] >> 2) & 0x03;
8421 #line 970 "rx-decode.opc"
8422                       int sd AU = op[1] & 0x03;
8423 #line 970 "rx-decode.opc"
8424                       int rdst AU = (op[2] >> 4) & 0x0f;
8425 #line 970 "rx-decode.opc"
8426                       int cond AU = op[2] & 0x0f;
8427                       if (trace)
8428                         {
8429                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8430                                  "/** 1111 1100 1101 sz sd rdst cond    sc%1%s  %0 */",
8431                                  op[0], op[1], op[2]);
8432                           printf ("  sz = 0x%x,", sz);
8433                           printf ("  sd = 0x%x,", sd);
8434                           printf ("  rdst = 0x%x,", rdst);
8435                           printf ("  cond = 0x%x\n", cond);
8436                         }
8437                       SYNTAX("sc%1%s    %0");
8438 #line 970 "rx-decode.opc"
8439                       ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8440
8441                     }
8442                   break;
8443               }
8444             break;
8445           case 0xd1:
8446               GETBYTE ();
8447               switch (op[2] & 0x00)
8448               {
8449                 case 0x00:
8450                   goto op_semantics_68;
8451                   break;
8452               }
8453             break;
8454           case 0xd2:
8455               GETBYTE ();
8456               switch (op[2] & 0x00)
8457               {
8458                 case 0x00:
8459                   goto op_semantics_68;
8460                   break;
8461               }
8462             break;
8463           case 0xd3:
8464               GETBYTE ();
8465               switch (op[2] & 0x00)
8466               {
8467                 case 0x00:
8468                   goto op_semantics_68;
8469                   break;
8470               }
8471             break;
8472           case 0xd4:
8473               GETBYTE ();
8474               switch (op[2] & 0x00)
8475               {
8476                 case 0x00:
8477                   goto op_semantics_68;
8478                   break;
8479               }
8480             break;
8481           case 0xd5:
8482               GETBYTE ();
8483               switch (op[2] & 0x00)
8484               {
8485                 case 0x00:
8486                   goto op_semantics_68;
8487                   break;
8488               }
8489             break;
8490           case 0xd6:
8491               GETBYTE ();
8492               switch (op[2] & 0x00)
8493               {
8494                 case 0x00:
8495                   goto op_semantics_68;
8496                   break;
8497               }
8498             break;
8499           case 0xd7:
8500               GETBYTE ();
8501               switch (op[2] & 0x00)
8502               {
8503                 case 0x00:
8504                   goto op_semantics_68;
8505                   break;
8506               }
8507             break;
8508           case 0xd8:
8509               GETBYTE ();
8510               switch (op[2] & 0x00)
8511               {
8512                 case 0x00:
8513                   goto op_semantics_68;
8514                   break;
8515               }
8516             break;
8517           case 0xd9:
8518               GETBYTE ();
8519               switch (op[2] & 0x00)
8520               {
8521                 case 0x00:
8522                   goto op_semantics_68;
8523                   break;
8524               }
8525             break;
8526           case 0xda:
8527               GETBYTE ();
8528               switch (op[2] & 0x00)
8529               {
8530                 case 0x00:
8531                   goto op_semantics_68;
8532                   break;
8533               }
8534             break;
8535           case 0xdb:
8536               GETBYTE ();
8537               switch (op[2] & 0x00)
8538               {
8539                 case 0x00:
8540                   goto op_semantics_68;
8541                   break;
8542               }
8543             break;
8544           case 0xe0:
8545               GETBYTE ();
8546               switch (op[2] & 0x0f)
8547               {
8548                 case 0x00:
8549                 case 0x01:
8550                 case 0x02:
8551                 case 0x03:
8552                 case 0x04:
8553                 case 0x05:
8554                 case 0x06:
8555                 case 0x07:
8556                 case 0x08:
8557                 case 0x09:
8558                 case 0x0a:
8559                 case 0x0b:
8560                 case 0x0c:
8561                 case 0x0d:
8562                 case 0x0e:
8563                   op_semantics_69:
8564                     {
8565                       /** 1111 1100 111bit sd rdst cond bm%2    #%1, %0%S0 */
8566 #line 913 "rx-decode.opc"
8567                       int bit AU = (op[1] >> 2) & 0x07;
8568 #line 913 "rx-decode.opc"
8569                       int sd AU = op[1] & 0x03;
8570 #line 913 "rx-decode.opc"
8571                       int rdst AU = (op[2] >> 4) & 0x0f;
8572 #line 913 "rx-decode.opc"
8573                       int cond AU = op[2] & 0x0f;
8574                       if (trace)
8575                         {
8576                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8577                                  "/** 1111 1100 111bit sd rdst cond     bm%2    #%1, %0%S0 */",
8578                                  op[0], op[1], op[2]);
8579                           printf ("  bit = 0x%x,", bit);
8580                           printf ("  sd = 0x%x,", sd);
8581                           printf ("  rdst = 0x%x,", rdst);
8582                           printf ("  cond = 0x%x\n", cond);
8583                         }
8584                       SYNTAX("bm%2      #%1, %0%S0");
8585 #line 913 "rx-decode.opc"
8586                       ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
8587
8588                     }
8589                   break;
8590                 case 0x0f:
8591                   op_semantics_70:
8592                     {
8593                       /** 1111 1100 111bit sd rdst 1111 bnot    #%1, %0%S0 */
8594 #line 903 "rx-decode.opc"
8595                       int bit AU = (op[1] >> 2) & 0x07;
8596 #line 903 "rx-decode.opc"
8597                       int sd AU = op[1] & 0x03;
8598 #line 903 "rx-decode.opc"
8599                       int rdst AU = (op[2] >> 4) & 0x0f;
8600                       if (trace)
8601                         {
8602                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8603                                  "/** 1111 1100 111bit sd rdst 1111     bnot    #%1, %0%S0 */",
8604                                  op[0], op[1], op[2]);
8605                           printf ("  bit = 0x%x,", bit);
8606                           printf ("  sd = 0x%x,", sd);
8607                           printf ("  rdst = 0x%x\n", rdst);
8608                         }
8609                       SYNTAX("bnot      #%1, %0%S0");
8610 #line 903 "rx-decode.opc"
8611                       ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
8612
8613                     }
8614                   break;
8615               }
8616             break;
8617           case 0xe1:
8618               GETBYTE ();
8619               switch (op[2] & 0x0f)
8620               {
8621                 case 0x00:
8622                 case 0x01:
8623                 case 0x02:
8624                 case 0x03:
8625                 case 0x04:
8626                 case 0x05:
8627                 case 0x06:
8628                 case 0x07:
8629                 case 0x08:
8630                 case 0x09:
8631                 case 0x0a:
8632                 case 0x0b:
8633                 case 0x0c:
8634                 case 0x0d:
8635                 case 0x0e:
8636                   goto op_semantics_69;
8637                   break;
8638                 case 0x0f:
8639                   goto op_semantics_70;
8640                   break;
8641               }
8642             break;
8643           case 0xe2:
8644               GETBYTE ();
8645               switch (op[2] & 0x0f)
8646               {
8647                 case 0x00:
8648                 case 0x01:
8649                 case 0x02:
8650                 case 0x03:
8651                 case 0x04:
8652                 case 0x05:
8653                 case 0x06:
8654                 case 0x07:
8655                 case 0x08:
8656                 case 0x09:
8657                 case 0x0a:
8658                 case 0x0b:
8659                 case 0x0c:
8660                 case 0x0d:
8661                 case 0x0e:
8662                   goto op_semantics_69;
8663                   break;
8664                 case 0x0f:
8665                   goto op_semantics_70;
8666                   break;
8667               }
8668             break;
8669           case 0xe3:
8670               GETBYTE ();
8671               switch (op[2] & 0x0f)
8672               {
8673                 case 0x00:
8674                 case 0x01:
8675                 case 0x02:
8676                 case 0x03:
8677                 case 0x04:
8678                 case 0x05:
8679                 case 0x06:
8680                 case 0x07:
8681                 case 0x08:
8682                 case 0x09:
8683                 case 0x0a:
8684                 case 0x0b:
8685                 case 0x0c:
8686                 case 0x0d:
8687                 case 0x0e:
8688                   goto op_semantics_69;
8689                   break;
8690                 case 0x0f:
8691                   goto op_semantics_70;
8692                   break;
8693               }
8694             break;
8695           case 0xe4:
8696               GETBYTE ();
8697               switch (op[2] & 0x0f)
8698               {
8699                 case 0x00:
8700                 case 0x01:
8701                 case 0x02:
8702                 case 0x03:
8703                 case 0x04:
8704                 case 0x05:
8705                 case 0x06:
8706                 case 0x07:
8707                 case 0x08:
8708                 case 0x09:
8709                 case 0x0a:
8710                 case 0x0b:
8711                 case 0x0c:
8712                 case 0x0d:
8713                 case 0x0e:
8714                   goto op_semantics_69;
8715                   break;
8716                 case 0x0f:
8717                   goto op_semantics_70;
8718                   break;
8719               }
8720             break;
8721           case 0xe5:
8722               GETBYTE ();
8723               switch (op[2] & 0x0f)
8724               {
8725                 case 0x00:
8726                 case 0x01:
8727                 case 0x02:
8728                 case 0x03:
8729                 case 0x04:
8730                 case 0x05:
8731                 case 0x06:
8732                 case 0x07:
8733                 case 0x08:
8734                 case 0x09:
8735                 case 0x0a:
8736                 case 0x0b:
8737                 case 0x0c:
8738                 case 0x0d:
8739                 case 0x0e:
8740                   goto op_semantics_69;
8741                   break;
8742                 case 0x0f:
8743                   goto op_semantics_70;
8744                   break;
8745               }
8746             break;
8747           case 0xe6:
8748               GETBYTE ();
8749               switch (op[2] & 0x0f)
8750               {
8751                 case 0x00:
8752                 case 0x01:
8753                 case 0x02:
8754                 case 0x03:
8755                 case 0x04:
8756                 case 0x05:
8757                 case 0x06:
8758                 case 0x07:
8759                 case 0x08:
8760                 case 0x09:
8761                 case 0x0a:
8762                 case 0x0b:
8763                 case 0x0c:
8764                 case 0x0d:
8765                 case 0x0e:
8766                   goto op_semantics_69;
8767                   break;
8768                 case 0x0f:
8769                   goto op_semantics_70;
8770                   break;
8771               }
8772             break;
8773           case 0xe7:
8774               GETBYTE ();
8775               switch (op[2] & 0x0f)
8776               {
8777                 case 0x00:
8778                 case 0x01:
8779                 case 0x02:
8780                 case 0x03:
8781                 case 0x04:
8782                 case 0x05:
8783                 case 0x06:
8784                 case 0x07:
8785                 case 0x08:
8786                 case 0x09:
8787                 case 0x0a:
8788                 case 0x0b:
8789                 case 0x0c:
8790                 case 0x0d:
8791                 case 0x0e:
8792                   goto op_semantics_69;
8793                   break;
8794                 case 0x0f:
8795                   goto op_semantics_70;
8796                   break;
8797               }
8798             break;
8799           case 0xe8:
8800               GETBYTE ();
8801               switch (op[2] & 0x0f)
8802               {
8803                 case 0x00:
8804                 case 0x01:
8805                 case 0x02:
8806                 case 0x03:
8807                 case 0x04:
8808                 case 0x05:
8809                 case 0x06:
8810                 case 0x07:
8811                 case 0x08:
8812                 case 0x09:
8813                 case 0x0a:
8814                 case 0x0b:
8815                 case 0x0c:
8816                 case 0x0d:
8817                 case 0x0e:
8818                   goto op_semantics_69;
8819                   break;
8820                 case 0x0f:
8821                   goto op_semantics_70;
8822                   break;
8823               }
8824             break;
8825           case 0xe9:
8826               GETBYTE ();
8827               switch (op[2] & 0x0f)
8828               {
8829                 case 0x00:
8830                 case 0x01:
8831                 case 0x02:
8832                 case 0x03:
8833                 case 0x04:
8834                 case 0x05:
8835                 case 0x06:
8836                 case 0x07:
8837                 case 0x08:
8838                 case 0x09:
8839                 case 0x0a:
8840                 case 0x0b:
8841                 case 0x0c:
8842                 case 0x0d:
8843                 case 0x0e:
8844                   goto op_semantics_69;
8845                   break;
8846                 case 0x0f:
8847                   goto op_semantics_70;
8848                   break;
8849               }
8850             break;
8851           case 0xea:
8852               GETBYTE ();
8853               switch (op[2] & 0x0f)
8854               {
8855                 case 0x00:
8856                 case 0x01:
8857                 case 0x02:
8858                 case 0x03:
8859                 case 0x04:
8860                 case 0x05:
8861                 case 0x06:
8862                 case 0x07:
8863                 case 0x08:
8864                 case 0x09:
8865                 case 0x0a:
8866                 case 0x0b:
8867                 case 0x0c:
8868                 case 0x0d:
8869                 case 0x0e:
8870                   goto op_semantics_69;
8871                   break;
8872                 case 0x0f:
8873                   goto op_semantics_70;
8874                   break;
8875               }
8876             break;
8877           case 0xeb:
8878               GETBYTE ();
8879               switch (op[2] & 0x0f)
8880               {
8881                 case 0x00:
8882                 case 0x01:
8883                 case 0x02:
8884                 case 0x03:
8885                 case 0x04:
8886                 case 0x05:
8887                 case 0x06:
8888                 case 0x07:
8889                 case 0x08:
8890                 case 0x09:
8891                 case 0x0a:
8892                 case 0x0b:
8893                 case 0x0c:
8894                 case 0x0d:
8895                 case 0x0e:
8896                   goto op_semantics_69;
8897                   break;
8898                 case 0x0f:
8899                   goto op_semantics_70;
8900                   break;
8901               }
8902             break;
8903           case 0xec:
8904               GETBYTE ();
8905               switch (op[2] & 0x0f)
8906               {
8907                 case 0x00:
8908                 case 0x01:
8909                 case 0x02:
8910                 case 0x03:
8911                 case 0x04:
8912                 case 0x05:
8913                 case 0x06:
8914                 case 0x07:
8915                 case 0x08:
8916                 case 0x09:
8917                 case 0x0a:
8918                 case 0x0b:
8919                 case 0x0c:
8920                 case 0x0d:
8921                 case 0x0e:
8922                   goto op_semantics_69;
8923                   break;
8924                 case 0x0f:
8925                   goto op_semantics_70;
8926                   break;
8927               }
8928             break;
8929           case 0xed:
8930               GETBYTE ();
8931               switch (op[2] & 0x0f)
8932               {
8933                 case 0x00:
8934                 case 0x01:
8935                 case 0x02:
8936                 case 0x03:
8937                 case 0x04:
8938                 case 0x05:
8939                 case 0x06:
8940                 case 0x07:
8941                 case 0x08:
8942                 case 0x09:
8943                 case 0x0a:
8944                 case 0x0b:
8945                 case 0x0c:
8946                 case 0x0d:
8947                 case 0x0e:
8948                   goto op_semantics_69;
8949                   break;
8950                 case 0x0f:
8951                   goto op_semantics_70;
8952                   break;
8953               }
8954             break;
8955           case 0xee:
8956               GETBYTE ();
8957               switch (op[2] & 0x0f)
8958               {
8959                 case 0x00:
8960                 case 0x01:
8961                 case 0x02:
8962                 case 0x03:
8963                 case 0x04:
8964                 case 0x05:
8965                 case 0x06:
8966                 case 0x07:
8967                 case 0x08:
8968                 case 0x09:
8969                 case 0x0a:
8970                 case 0x0b:
8971                 case 0x0c:
8972                 case 0x0d:
8973                 case 0x0e:
8974                   goto op_semantics_69;
8975                   break;
8976                 case 0x0f:
8977                   goto op_semantics_70;
8978                   break;
8979               }
8980             break;
8981           case 0xef:
8982               GETBYTE ();
8983               switch (op[2] & 0x0f)
8984               {
8985                 case 0x00:
8986                 case 0x01:
8987                 case 0x02:
8988                 case 0x03:
8989                 case 0x04:
8990                 case 0x05:
8991                 case 0x06:
8992                 case 0x07:
8993                 case 0x08:
8994                 case 0x09:
8995                 case 0x0a:
8996                 case 0x0b:
8997                 case 0x0c:
8998                 case 0x0d:
8999                 case 0x0e:
9000                   goto op_semantics_69;
9001                   break;
9002                 case 0x0f:
9003                   goto op_semantics_70;
9004                   break;
9005               }
9006             break;
9007           case 0xf0:
9008               GETBYTE ();
9009               switch (op[2] & 0x0f)
9010               {
9011                 case 0x00:
9012                 case 0x01:
9013                 case 0x02:
9014                 case 0x03:
9015                 case 0x04:
9016                 case 0x05:
9017                 case 0x06:
9018                 case 0x07:
9019                 case 0x08:
9020                 case 0x09:
9021                 case 0x0a:
9022                 case 0x0b:
9023                 case 0x0c:
9024                 case 0x0d:
9025                 case 0x0e:
9026                   goto op_semantics_69;
9027                   break;
9028                 case 0x0f:
9029                   goto op_semantics_70;
9030                   break;
9031               }
9032             break;
9033           case 0xf1:
9034               GETBYTE ();
9035               switch (op[2] & 0x0f)
9036               {
9037                 case 0x00:
9038                 case 0x01:
9039                 case 0x02:
9040                 case 0x03:
9041                 case 0x04:
9042                 case 0x05:
9043                 case 0x06:
9044                 case 0x07:
9045                 case 0x08:
9046                 case 0x09:
9047                 case 0x0a:
9048                 case 0x0b:
9049                 case 0x0c:
9050                 case 0x0d:
9051                 case 0x0e:
9052                   goto op_semantics_69;
9053                   break;
9054                 case 0x0f:
9055                   goto op_semantics_70;
9056                   break;
9057               }
9058             break;
9059           case 0xf2:
9060               GETBYTE ();
9061               switch (op[2] & 0x0f)
9062               {
9063                 case 0x00:
9064                 case 0x01:
9065                 case 0x02:
9066                 case 0x03:
9067                 case 0x04:
9068                 case 0x05:
9069                 case 0x06:
9070                 case 0x07:
9071                 case 0x08:
9072                 case 0x09:
9073                 case 0x0a:
9074                 case 0x0b:
9075                 case 0x0c:
9076                 case 0x0d:
9077                 case 0x0e:
9078                   goto op_semantics_69;
9079                   break;
9080                 case 0x0f:
9081                   goto op_semantics_70;
9082                   break;
9083               }
9084             break;
9085           case 0xf3:
9086               GETBYTE ();
9087               switch (op[2] & 0x0f)
9088               {
9089                 case 0x00:
9090                 case 0x01:
9091                 case 0x02:
9092                 case 0x03:
9093                 case 0x04:
9094                 case 0x05:
9095                 case 0x06:
9096                 case 0x07:
9097                 case 0x08:
9098                 case 0x09:
9099                 case 0x0a:
9100                 case 0x0b:
9101                 case 0x0c:
9102                 case 0x0d:
9103                 case 0x0e:
9104                   goto op_semantics_69;
9105                   break;
9106                 case 0x0f:
9107                   goto op_semantics_70;
9108                   break;
9109               }
9110             break;
9111           case 0xf4:
9112               GETBYTE ();
9113               switch (op[2] & 0x0f)
9114               {
9115                 case 0x00:
9116                 case 0x01:
9117                 case 0x02:
9118                 case 0x03:
9119                 case 0x04:
9120                 case 0x05:
9121                 case 0x06:
9122                 case 0x07:
9123                 case 0x08:
9124                 case 0x09:
9125                 case 0x0a:
9126                 case 0x0b:
9127                 case 0x0c:
9128                 case 0x0d:
9129                 case 0x0e:
9130                   goto op_semantics_69;
9131                   break;
9132                 case 0x0f:
9133                   goto op_semantics_70;
9134                   break;
9135               }
9136             break;
9137           case 0xf5:
9138               GETBYTE ();
9139               switch (op[2] & 0x0f)
9140               {
9141                 case 0x00:
9142                 case 0x01:
9143                 case 0x02:
9144                 case 0x03:
9145                 case 0x04:
9146                 case 0x05:
9147                 case 0x06:
9148                 case 0x07:
9149                 case 0x08:
9150                 case 0x09:
9151                 case 0x0a:
9152                 case 0x0b:
9153                 case 0x0c:
9154                 case 0x0d:
9155                 case 0x0e:
9156                   goto op_semantics_69;
9157                   break;
9158                 case 0x0f:
9159                   goto op_semantics_70;
9160                   break;
9161               }
9162             break;
9163           case 0xf6:
9164               GETBYTE ();
9165               switch (op[2] & 0x0f)
9166               {
9167                 case 0x00:
9168                 case 0x01:
9169                 case 0x02:
9170                 case 0x03:
9171                 case 0x04:
9172                 case 0x05:
9173                 case 0x06:
9174                 case 0x07:
9175                 case 0x08:
9176                 case 0x09:
9177                 case 0x0a:
9178                 case 0x0b:
9179                 case 0x0c:
9180                 case 0x0d:
9181                 case 0x0e:
9182                   goto op_semantics_69;
9183                   break;
9184                 case 0x0f:
9185                   goto op_semantics_70;
9186                   break;
9187               }
9188             break;
9189           case 0xf7:
9190               GETBYTE ();
9191               switch (op[2] & 0x0f)
9192               {
9193                 case 0x00:
9194                 case 0x01:
9195                 case 0x02:
9196                 case 0x03:
9197                 case 0x04:
9198                 case 0x05:
9199                 case 0x06:
9200                 case 0x07:
9201                 case 0x08:
9202                 case 0x09:
9203                 case 0x0a:
9204                 case 0x0b:
9205                 case 0x0c:
9206                 case 0x0d:
9207                 case 0x0e:
9208                   goto op_semantics_69;
9209                   break;
9210                 case 0x0f:
9211                   goto op_semantics_70;
9212                   break;
9213               }
9214             break;
9215           case 0xf8:
9216               GETBYTE ();
9217               switch (op[2] & 0x0f)
9218               {
9219                 case 0x00:
9220                 case 0x01:
9221                 case 0x02:
9222                 case 0x03:
9223                 case 0x04:
9224                 case 0x05:
9225                 case 0x06:
9226                 case 0x07:
9227                 case 0x08:
9228                 case 0x09:
9229                 case 0x0a:
9230                 case 0x0b:
9231                 case 0x0c:
9232                 case 0x0d:
9233                 case 0x0e:
9234                   goto op_semantics_69;
9235                   break;
9236                 case 0x0f:
9237                   goto op_semantics_70;
9238                   break;
9239               }
9240             break;
9241           case 0xf9:
9242               GETBYTE ();
9243               switch (op[2] & 0x0f)
9244               {
9245                 case 0x00:
9246                 case 0x01:
9247                 case 0x02:
9248                 case 0x03:
9249                 case 0x04:
9250                 case 0x05:
9251                 case 0x06:
9252                 case 0x07:
9253                 case 0x08:
9254                 case 0x09:
9255                 case 0x0a:
9256                 case 0x0b:
9257                 case 0x0c:
9258                 case 0x0d:
9259                 case 0x0e:
9260                   goto op_semantics_69;
9261                   break;
9262                 case 0x0f:
9263                   goto op_semantics_70;
9264                   break;
9265               }
9266             break;
9267           case 0xfa:
9268               GETBYTE ();
9269               switch (op[2] & 0x0f)
9270               {
9271                 case 0x00:
9272                 case 0x01:
9273                 case 0x02:
9274                 case 0x03:
9275                 case 0x04:
9276                 case 0x05:
9277                 case 0x06:
9278                 case 0x07:
9279                 case 0x08:
9280                 case 0x09:
9281                 case 0x0a:
9282                 case 0x0b:
9283                 case 0x0c:
9284                 case 0x0d:
9285                 case 0x0e:
9286                   goto op_semantics_69;
9287                   break;
9288                 case 0x0f:
9289                   goto op_semantics_70;
9290                   break;
9291               }
9292             break;
9293           case 0xfb:
9294               GETBYTE ();
9295               switch (op[2] & 0x0f)
9296               {
9297                 case 0x00:
9298                 case 0x01:
9299                 case 0x02:
9300                 case 0x03:
9301                 case 0x04:
9302                 case 0x05:
9303                 case 0x06:
9304                 case 0x07:
9305                 case 0x08:
9306                 case 0x09:
9307                 case 0x0a:
9308                 case 0x0b:
9309                 case 0x0c:
9310                 case 0x0d:
9311                 case 0x0e:
9312                   goto op_semantics_69;
9313                   break;
9314                 case 0x0f:
9315                   goto op_semantics_70;
9316                   break;
9317               }
9318             break;
9319           case 0xfc:
9320               GETBYTE ();
9321               switch (op[2] & 0x0f)
9322               {
9323                 case 0x00:
9324                 case 0x01:
9325                 case 0x02:
9326                 case 0x03:
9327                 case 0x04:
9328                 case 0x05:
9329                 case 0x06:
9330                 case 0x07:
9331                 case 0x08:
9332                 case 0x09:
9333                 case 0x0a:
9334                 case 0x0b:
9335                 case 0x0c:
9336                 case 0x0d:
9337                 case 0x0e:
9338                   goto op_semantics_69;
9339                   break;
9340                 case 0x0f:
9341                   goto op_semantics_70;
9342                   break;
9343               }
9344             break;
9345           case 0xfd:
9346               GETBYTE ();
9347               switch (op[2] & 0x0f)
9348               {
9349                 case 0x00:
9350                 case 0x01:
9351                 case 0x02:
9352                 case 0x03:
9353                 case 0x04:
9354                 case 0x05:
9355                 case 0x06:
9356                 case 0x07:
9357                 case 0x08:
9358                 case 0x09:
9359                 case 0x0a:
9360                 case 0x0b:
9361                 case 0x0c:
9362                 case 0x0d:
9363                 case 0x0e:
9364                   goto op_semantics_69;
9365                   break;
9366                 case 0x0f:
9367                   goto op_semantics_70;
9368                   break;
9369               }
9370             break;
9371           case 0xfe:
9372               GETBYTE ();
9373               switch (op[2] & 0x0f)
9374               {
9375                 case 0x00:
9376                 case 0x01:
9377                 case 0x02:
9378                 case 0x03:
9379                 case 0x04:
9380                 case 0x05:
9381                 case 0x06:
9382                 case 0x07:
9383                 case 0x08:
9384                 case 0x09:
9385                 case 0x0a:
9386                 case 0x0b:
9387                 case 0x0c:
9388                 case 0x0d:
9389                 case 0x0e:
9390                   goto op_semantics_69;
9391                   break;
9392                 case 0x0f:
9393                   goto op_semantics_70;
9394                   break;
9395               }
9396             break;
9397           case 0xff:
9398               GETBYTE ();
9399               switch (op[2] & 0x0f)
9400               {
9401                 case 0x00:
9402                 case 0x01:
9403                 case 0x02:
9404                 case 0x03:
9405                 case 0x04:
9406                 case 0x05:
9407                 case 0x06:
9408                 case 0x07:
9409                 case 0x08:
9410                 case 0x09:
9411                 case 0x0a:
9412                 case 0x0b:
9413                 case 0x0c:
9414                 case 0x0d:
9415                 case 0x0e:
9416                   goto op_semantics_69;
9417                   break;
9418                 case 0x0f:
9419                   goto op_semantics_70;
9420                   break;
9421               }
9422             break;
9423           default: UNSUPPORTED(); break;
9424         }
9425       break;
9426     case 0xfd:
9427         GETBYTE ();
9428         switch (op[1] & 0xff)
9429         {
9430           case 0x00:
9431               GETBYTE ();
9432               switch (op[2] & 0x00)
9433               {
9434                 case 0x00:
9435                     {
9436                       /** 1111 1101 0000 0000 srca srcb mulhi   %1, %2 */
9437 #line 786 "rx-decode.opc"
9438                       int srca AU = (op[2] >> 4) & 0x0f;
9439 #line 786 "rx-decode.opc"
9440                       int srcb AU = op[2] & 0x0f;
9441                       if (trace)
9442                         {
9443                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9444                                  "/** 1111 1101 0000 0000 srca srcb     mulhi   %1, %2 */",
9445                                  op[0], op[1], op[2]);
9446                           printf ("  srca = 0x%x,", srca);
9447                           printf ("  srcb = 0x%x\n", srcb);
9448                         }
9449                       SYNTAX("mulhi     %1, %2");
9450 #line 786 "rx-decode.opc"
9451                       ID(mulhi); SR(srca); S2R(srcb); F_____;
9452
9453                     }
9454                   break;
9455               }
9456             break;
9457           case 0x01:
9458               GETBYTE ();
9459               switch (op[2] & 0x00)
9460               {
9461                 case 0x00:
9462                     {
9463                       /** 1111 1101 0000 0001 srca srcb mullo   %1, %2 */
9464 #line 789 "rx-decode.opc"
9465                       int srca AU = (op[2] >> 4) & 0x0f;
9466 #line 789 "rx-decode.opc"
9467                       int srcb AU = op[2] & 0x0f;
9468                       if (trace)
9469                         {
9470                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9471                                  "/** 1111 1101 0000 0001 srca srcb     mullo   %1, %2 */",
9472                                  op[0], op[1], op[2]);
9473                           printf ("  srca = 0x%x,", srca);
9474                           printf ("  srcb = 0x%x\n", srcb);
9475                         }
9476                       SYNTAX("mullo     %1, %2");
9477 #line 789 "rx-decode.opc"
9478                       ID(mullo); SR(srca); S2R(srcb); F_____;
9479
9480                     }
9481                   break;
9482               }
9483             break;
9484           case 0x04:
9485               GETBYTE ();
9486               switch (op[2] & 0x00)
9487               {
9488                 case 0x00:
9489                     {
9490                       /** 1111 1101 0000 0100 srca srcb machi   %1, %2 */
9491 #line 792 "rx-decode.opc"
9492                       int srca AU = (op[2] >> 4) & 0x0f;
9493 #line 792 "rx-decode.opc"
9494                       int srcb AU = op[2] & 0x0f;
9495                       if (trace)
9496                         {
9497                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9498                                  "/** 1111 1101 0000 0100 srca srcb     machi   %1, %2 */",
9499                                  op[0], op[1], op[2]);
9500                           printf ("  srca = 0x%x,", srca);
9501                           printf ("  srcb = 0x%x\n", srcb);
9502                         }
9503                       SYNTAX("machi     %1, %2");
9504 #line 792 "rx-decode.opc"
9505                       ID(machi); SR(srca); S2R(srcb); F_____;
9506
9507                     }
9508                   break;
9509               }
9510             break;
9511           case 0x05:
9512               GETBYTE ();
9513               switch (op[2] & 0x00)
9514               {
9515                 case 0x00:
9516                     {
9517                       /** 1111 1101 0000 0101 srca srcb maclo   %1, %2 */
9518 #line 795 "rx-decode.opc"
9519                       int srca AU = (op[2] >> 4) & 0x0f;
9520 #line 795 "rx-decode.opc"
9521                       int srcb AU = op[2] & 0x0f;
9522                       if (trace)
9523                         {
9524                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9525                                  "/** 1111 1101 0000 0101 srca srcb     maclo   %1, %2 */",
9526                                  op[0], op[1], op[2]);
9527                           printf ("  srca = 0x%x,", srca);
9528                           printf ("  srcb = 0x%x\n", srcb);
9529                         }
9530                       SYNTAX("maclo     %1, %2");
9531 #line 795 "rx-decode.opc"
9532                       ID(maclo); SR(srca); S2R(srcb); F_____;
9533
9534                     }
9535                   break;
9536               }
9537             break;
9538           case 0x17:
9539               GETBYTE ();
9540               switch (op[2] & 0xf0)
9541               {
9542                 case 0x00:
9543                     {
9544                       /** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */
9545 #line 798 "rx-decode.opc"
9546                       int rsrc AU = op[2] & 0x0f;
9547                       if (trace)
9548                         {
9549                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9550                                  "/** 1111 1101 0001 0111 0000 rsrc     mvtachi %1 */",
9551                                  op[0], op[1], op[2]);
9552                           printf ("  rsrc = 0x%x\n", rsrc);
9553                         }
9554                       SYNTAX("mvtachi   %1");
9555 #line 798 "rx-decode.opc"
9556                       ID(mvtachi); SR(rsrc); F_____;
9557
9558                     }
9559                   break;
9560                 case 0x10:
9561                     {
9562                       /** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */
9563 #line 801 "rx-decode.opc"
9564                       int rsrc AU = op[2] & 0x0f;
9565                       if (trace)
9566                         {
9567                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9568                                  "/** 1111 1101 0001 0111 0001 rsrc     mvtaclo %1 */",
9569                                  op[0], op[1], op[2]);
9570                           printf ("  rsrc = 0x%x\n", rsrc);
9571                         }
9572                       SYNTAX("mvtaclo   %1");
9573 #line 801 "rx-decode.opc"
9574                       ID(mvtaclo); SR(rsrc); F_____;
9575
9576                     }
9577                   break;
9578                 default: UNSUPPORTED(); break;
9579               }
9580             break;
9581           case 0x18:
9582               GETBYTE ();
9583               switch (op[2] & 0xef)
9584               {
9585                 case 0x00:
9586                     {
9587                       /** 1111 1101 0001 1000 000i 0000 racw    #%1 */
9588 #line 813 "rx-decode.opc"
9589                       int i AU = (op[2] >> 4) & 0x01;
9590                       if (trace)
9591                         {
9592                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9593                                  "/** 1111 1101 0001 1000 000i 0000     racw    #%1 */",
9594                                  op[0], op[1], op[2]);
9595                           printf ("  i = 0x%x\n", i);
9596                         }
9597                       SYNTAX("racw      #%1");
9598 #line 813 "rx-decode.opc"
9599                       ID(racw); SC(i+1); F_____;
9600
9601                     /*----------------------------------------------------------------------*/
9602                     /* SAT                                                                      */
9603
9604                     }
9605                   break;
9606                 default: UNSUPPORTED(); break;
9607               }
9608             break;
9609           case 0x1f:
9610               GETBYTE ();
9611               switch (op[2] & 0xf0)
9612               {
9613                 case 0x00:
9614                     {
9615                       /** 1111 1101 0001 1111 0000 rdst mvfachi %0 */
9616 #line 804 "rx-decode.opc"
9617                       int rdst AU = op[2] & 0x0f;
9618                       if (trace)
9619                         {
9620                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9621                                  "/** 1111 1101 0001 1111 0000 rdst     mvfachi %0 */",
9622                                  op[0], op[1], op[2]);
9623                           printf ("  rdst = 0x%x\n", rdst);
9624                         }
9625                       SYNTAX("mvfachi   %0");
9626 #line 804 "rx-decode.opc"
9627                       ID(mvfachi); DR(rdst); F_____;
9628
9629                     }
9630                   break;
9631                 case 0x10:
9632                     {
9633                       /** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */
9634 #line 810 "rx-decode.opc"
9635                       int rdst AU = op[2] & 0x0f;
9636                       if (trace)
9637                         {
9638                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9639                                  "/** 1111 1101 0001 1111 0001 rdst     mvfaclo %0 */",
9640                                  op[0], op[1], op[2]);
9641                           printf ("  rdst = 0x%x\n", rdst);
9642                         }
9643                       SYNTAX("mvfaclo   %0");
9644 #line 810 "rx-decode.opc"
9645                       ID(mvfaclo); DR(rdst); F_____;
9646
9647                     }
9648                   break;
9649                 case 0x20:
9650                     {
9651                       /** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */
9652 #line 807 "rx-decode.opc"
9653                       int rdst AU = op[2] & 0x0f;
9654                       if (trace)
9655                         {
9656                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9657                                  "/** 1111 1101 0001 1111 0010 rdst     mvfacmi %0 */",
9658                                  op[0], op[1], op[2]);
9659                           printf ("  rdst = 0x%x\n", rdst);
9660                         }
9661                       SYNTAX("mvfacmi   %0");
9662 #line 807 "rx-decode.opc"
9663                       ID(mvfacmi); DR(rdst); F_____;
9664
9665                     }
9666                   break;
9667                 default: UNSUPPORTED(); break;
9668               }
9669             break;
9670           case 0x20:
9671               GETBYTE ();
9672               switch (op[2] & 0x00)
9673               {
9674                 case 0x00:
9675                   op_semantics_71:
9676                     {
9677                       /** 1111 1101 0010 0p sz rdst rsrc        mov%s   %1, %0 */
9678 #line 320 "rx-decode.opc"
9679                       int p AU = (op[1] >> 2) & 0x01;
9680 #line 320 "rx-decode.opc"
9681                       int sz AU = op[1] & 0x03;
9682 #line 320 "rx-decode.opc"
9683                       int rdst AU = (op[2] >> 4) & 0x0f;
9684 #line 320 "rx-decode.opc"
9685                       int rsrc AU = op[2] & 0x0f;
9686                       if (trace)
9687                         {
9688                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9689                                  "/** 1111 1101 0010 0p sz rdst rsrc    mov%s   %1, %0 */",
9690                                  op[0], op[1], op[2]);
9691                           printf ("  p = 0x%x,", p);
9692                           printf ("  sz = 0x%x,", sz);
9693                           printf ("  rdst = 0x%x,", rdst);
9694                           printf ("  rsrc = 0x%x\n", rsrc);
9695                         }
9696                       SYNTAX("mov%s     %1, %0");
9697 #line 320 "rx-decode.opc"
9698                       ID(mov); sBWL (sz); SR(rsrc); F_____;
9699                       OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
9700
9701                     }
9702                   break;
9703               }
9704             break;
9705           case 0x21:
9706               GETBYTE ();
9707               switch (op[2] & 0x00)
9708               {
9709                 case 0x00:
9710                   goto op_semantics_71;
9711                   break;
9712               }
9713             break;
9714           case 0x22:
9715               GETBYTE ();
9716               switch (op[2] & 0x00)
9717               {
9718                 case 0x00:
9719                   goto op_semantics_71;
9720                   break;
9721               }
9722             break;
9723           case 0x24:
9724               GETBYTE ();
9725               switch (op[2] & 0x00)
9726               {
9727                 case 0x00:
9728                   goto op_semantics_71;
9729                   break;
9730               }
9731             break;
9732           case 0x25:
9733               GETBYTE ();
9734               switch (op[2] & 0x00)
9735               {
9736                 case 0x00:
9737                   goto op_semantics_71;
9738                   break;
9739               }
9740             break;
9741           case 0x26:
9742               GETBYTE ();
9743               switch (op[2] & 0x00)
9744               {
9745                 case 0x00:
9746                   goto op_semantics_71;
9747                   break;
9748               }
9749             break;
9750           case 0x28:
9751               GETBYTE ();
9752               switch (op[2] & 0x00)
9753               {
9754                 case 0x00:
9755                   op_semantics_72:
9756                     {
9757                       /** 1111 1101 0010 1p sz rsrc rdst        mov%s   %1, %0 */
9758 #line 324 "rx-decode.opc"
9759                       int p AU = (op[1] >> 2) & 0x01;
9760 #line 324 "rx-decode.opc"
9761                       int sz AU = op[1] & 0x03;
9762 #line 324 "rx-decode.opc"
9763                       int rsrc AU = (op[2] >> 4) & 0x0f;
9764 #line 324 "rx-decode.opc"
9765                       int rdst AU = op[2] & 0x0f;
9766                       if (trace)
9767                         {
9768                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9769                                  "/** 1111 1101 0010 1p sz rsrc rdst    mov%s   %1, %0 */",
9770                                  op[0], op[1], op[2]);
9771                           printf ("  p = 0x%x,", p);
9772                           printf ("  sz = 0x%x,", sz);
9773                           printf ("  rsrc = 0x%x,", rsrc);
9774                           printf ("  rdst = 0x%x\n", rdst);
9775                         }
9776                       SYNTAX("mov%s     %1, %0");
9777 #line 324 "rx-decode.opc"
9778                       ID(mov); sBWL (sz); DR(rdst); F_____;
9779                       OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9780
9781                     }
9782                   break;
9783               }
9784             break;
9785           case 0x29:
9786               GETBYTE ();
9787               switch (op[2] & 0x00)
9788               {
9789                 case 0x00:
9790                   goto op_semantics_72;
9791                   break;
9792               }
9793             break;
9794           case 0x2a:
9795               GETBYTE ();
9796               switch (op[2] & 0x00)
9797               {
9798                 case 0x00:
9799                   goto op_semantics_72;
9800                   break;
9801               }
9802             break;
9803           case 0x2c:
9804               GETBYTE ();
9805               switch (op[2] & 0x00)
9806               {
9807                 case 0x00:
9808                   goto op_semantics_72;
9809                   break;
9810               }
9811             break;
9812           case 0x2d:
9813               GETBYTE ();
9814               switch (op[2] & 0x00)
9815               {
9816                 case 0x00:
9817                   goto op_semantics_72;
9818                   break;
9819               }
9820             break;
9821           case 0x2e:
9822               GETBYTE ();
9823               switch (op[2] & 0x00)
9824               {
9825                 case 0x00:
9826                   goto op_semantics_72;
9827                   break;
9828               }
9829             break;
9830           case 0x38:
9831               GETBYTE ();
9832               switch (op[2] & 0x00)
9833               {
9834                 case 0x00:
9835                   op_semantics_73:
9836                     {
9837                       /** 1111 1101 0011 1p sz rsrc rdst        movu%s  %1, %0 */
9838 #line 334 "rx-decode.opc"
9839                       int p AU = (op[1] >> 2) & 0x01;
9840 #line 334 "rx-decode.opc"
9841                       int sz AU = op[1] & 0x03;
9842 #line 334 "rx-decode.opc"
9843                       int rsrc AU = (op[2] >> 4) & 0x0f;
9844 #line 334 "rx-decode.opc"
9845                       int rdst AU = op[2] & 0x0f;
9846                       if (trace)
9847                         {
9848                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9849                                  "/** 1111 1101 0011 1p sz rsrc rdst    movu%s  %1, %0 */",
9850                                  op[0], op[1], op[2]);
9851                           printf ("  p = 0x%x,", p);
9852                           printf ("  sz = 0x%x,", sz);
9853                           printf ("  rsrc = 0x%x,", rsrc);
9854                           printf ("  rdst = 0x%x\n", rdst);
9855                         }
9856                       SYNTAX("movu%s    %1, %0");
9857 #line 334 "rx-decode.opc"
9858                       ID(mov); uBWL (sz); DR(rdst); F_____;
9859                        OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9860
9861                     /*----------------------------------------------------------------------*/
9862                     /* PUSH/POP                                                         */
9863
9864                     }
9865                   break;
9866               }
9867             break;
9868           case 0x39:
9869               GETBYTE ();
9870               switch (op[2] & 0x00)
9871               {
9872                 case 0x00:
9873                   goto op_semantics_73;
9874                   break;
9875               }
9876             break;
9877           case 0x3a:
9878               GETBYTE ();
9879               switch (op[2] & 0x00)
9880               {
9881                 case 0x00:
9882                   goto op_semantics_73;
9883                   break;
9884               }
9885             break;
9886           case 0x3c:
9887               GETBYTE ();
9888               switch (op[2] & 0x00)
9889               {
9890                 case 0x00:
9891                   goto op_semantics_73;
9892                   break;
9893               }
9894             break;
9895           case 0x3d:
9896               GETBYTE ();
9897               switch (op[2] & 0x00)
9898               {
9899                 case 0x00:
9900                   goto op_semantics_73;
9901                   break;
9902               }
9903             break;
9904           case 0x3e:
9905               GETBYTE ();
9906               switch (op[2] & 0x00)
9907               {
9908                 case 0x00:
9909                   goto op_semantics_73;
9910                   break;
9911               }
9912             break;
9913           case 0x60:
9914               GETBYTE ();
9915               switch (op[2] & 0x00)
9916               {
9917                 case 0x00:
9918                     {
9919                       /** 1111 1101 0110 0000 rsrc rdst shlr    %2, %0 */
9920 #line 667 "rx-decode.opc"
9921                       int rsrc AU = (op[2] >> 4) & 0x0f;
9922 #line 667 "rx-decode.opc"
9923                       int rdst AU = op[2] & 0x0f;
9924                       if (trace)
9925                         {
9926                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9927                                  "/** 1111 1101 0110 0000 rsrc rdst     shlr    %2, %0 */",
9928                                  op[0], op[1], op[2]);
9929                           printf ("  rsrc = 0x%x,", rsrc);
9930                           printf ("  rdst = 0x%x\n", rdst);
9931                         }
9932                       SYNTAX("shlr      %2, %0");
9933 #line 667 "rx-decode.opc"
9934                       ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
9935
9936                     }
9937                   break;
9938               }
9939             break;
9940           case 0x61:
9941               GETBYTE ();
9942               switch (op[2] & 0x00)
9943               {
9944                 case 0x00:
9945                     {
9946                       /** 1111 1101 0110 0001 rsrc rdst shar    %2, %0 */
9947 #line 657 "rx-decode.opc"
9948                       int rsrc AU = (op[2] >> 4) & 0x0f;
9949 #line 657 "rx-decode.opc"
9950                       int rdst AU = op[2] & 0x0f;
9951                       if (trace)
9952                         {
9953                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9954                                  "/** 1111 1101 0110 0001 rsrc rdst     shar    %2, %0 */",
9955                                  op[0], op[1], op[2]);
9956                           printf ("  rsrc = 0x%x,", rsrc);
9957                           printf ("  rdst = 0x%x\n", rdst);
9958                         }
9959                       SYNTAX("shar      %2, %0");
9960 #line 657 "rx-decode.opc"
9961                       ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
9962
9963                     }
9964                   break;
9965               }
9966             break;
9967           case 0x62:
9968               GETBYTE ();
9969               switch (op[2] & 0x00)
9970               {
9971                 case 0x00:
9972                     {
9973                       /** 1111 1101 0110 0010 rsrc rdst shll    %2, %0 */
9974 #line 647 "rx-decode.opc"
9975                       int rsrc AU = (op[2] >> 4) & 0x0f;
9976 #line 647 "rx-decode.opc"
9977                       int rdst AU = op[2] & 0x0f;
9978                       if (trace)
9979                         {
9980                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9981                                  "/** 1111 1101 0110 0010 rsrc rdst     shll    %2, %0 */",
9982                                  op[0], op[1], op[2]);
9983                           printf ("  rsrc = 0x%x,", rsrc);
9984                           printf ("  rdst = 0x%x\n", rdst);
9985                         }
9986                       SYNTAX("shll      %2, %0");
9987 #line 647 "rx-decode.opc"
9988                       ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
9989
9990                     }
9991                   break;
9992               }
9993             break;
9994           case 0x64:
9995               GETBYTE ();
9996               switch (op[2] & 0x00)
9997               {
9998                 case 0x00:
9999                     {
10000                       /** 1111 1101 0110 0100 rsrc rdst rotr    %1, %0 */
10001 #line 691 "rx-decode.opc"
10002                       int rsrc AU = (op[2] >> 4) & 0x0f;
10003 #line 691 "rx-decode.opc"
10004                       int rdst AU = op[2] & 0x0f;
10005                       if (trace)
10006                         {
10007                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10008                                  "/** 1111 1101 0110 0100 rsrc rdst     rotr    %1, %0 */",
10009                                  op[0], op[1], op[2]);
10010                           printf ("  rsrc = 0x%x,", rsrc);
10011                           printf ("  rdst = 0x%x\n", rdst);
10012                         }
10013                       SYNTAX("rotr      %1, %0");
10014 #line 691 "rx-decode.opc"
10015                       ID(rotr); SR(rsrc); DR(rdst); F__SZC;
10016
10017                     }
10018                   break;
10019               }
10020             break;
10021           case 0x65:
10022               GETBYTE ();
10023               switch (op[2] & 0x00)
10024               {
10025                 case 0x00:
10026                     {
10027                       /** 1111 1101 0110 0101 rsrc rdst revw    %1, %0 */
10028 #line 694 "rx-decode.opc"
10029                       int rsrc AU = (op[2] >> 4) & 0x0f;
10030 #line 694 "rx-decode.opc"
10031                       int rdst AU = op[2] & 0x0f;
10032                       if (trace)
10033                         {
10034                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10035                                  "/** 1111 1101 0110 0101 rsrc rdst     revw    %1, %0 */",
10036                                  op[0], op[1], op[2]);
10037                           printf ("  rsrc = 0x%x,", rsrc);
10038                           printf ("  rdst = 0x%x\n", rdst);
10039                         }
10040                       SYNTAX("revw      %1, %0");
10041 #line 694 "rx-decode.opc"
10042                       ID(revw); SR(rsrc); DR(rdst);
10043
10044                     }
10045                   break;
10046               }
10047             break;
10048           case 0x66:
10049               GETBYTE ();
10050               switch (op[2] & 0x00)
10051               {
10052                 case 0x00:
10053                     {
10054                       /** 1111 1101 0110 0110 rsrc rdst rotl    %1, %0 */
10055 #line 685 "rx-decode.opc"
10056                       int rsrc AU = (op[2] >> 4) & 0x0f;
10057 #line 685 "rx-decode.opc"
10058                       int rdst AU = op[2] & 0x0f;
10059                       if (trace)
10060                         {
10061                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10062                                  "/** 1111 1101 0110 0110 rsrc rdst     rotl    %1, %0 */",
10063                                  op[0], op[1], op[2]);
10064                           printf ("  rsrc = 0x%x,", rsrc);
10065                           printf ("  rdst = 0x%x\n", rdst);
10066                         }
10067                       SYNTAX("rotl      %1, %0");
10068 #line 685 "rx-decode.opc"
10069                       ID(rotl); SR(rsrc); DR(rdst); F__SZC;
10070
10071                     }
10072                   break;
10073               }
10074             break;
10075           case 0x67:
10076               GETBYTE ();
10077               switch (op[2] & 0x00)
10078               {
10079                 case 0x00:
10080                     {
10081                       /** 1111 1101 0110 0111 rsrc rdst revl    %1, %0 */
10082 #line 697 "rx-decode.opc"
10083                       int rsrc AU = (op[2] >> 4) & 0x0f;
10084 #line 697 "rx-decode.opc"
10085                       int rdst AU = op[2] & 0x0f;
10086                       if (trace)
10087                         {
10088                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10089                                  "/** 1111 1101 0110 0111 rsrc rdst     revl    %1, %0 */",
10090                                  op[0], op[1], op[2]);
10091                           printf ("  rsrc = 0x%x,", rsrc);
10092                           printf ("  rdst = 0x%x\n", rdst);
10093                         }
10094                       SYNTAX("revl      %1, %0");
10095 #line 697 "rx-decode.opc"
10096                       ID(revl); SR(rsrc); DR(rdst);
10097
10098                     /*----------------------------------------------------------------------*/
10099                     /* BRANCH                                                           */
10100
10101                     }
10102                   break;
10103               }
10104             break;
10105           case 0x68:
10106               GETBYTE ();
10107               switch (op[2] & 0x00)
10108               {
10109                 case 0x00:
10110                   op_semantics_74:
10111                     {
10112                       /** 1111 1101 0110 100c rsrc rdst mvtc    %1, %0 */
10113 #line 940 "rx-decode.opc"
10114                       int c AU = op[1] & 0x01;
10115 #line 940 "rx-decode.opc"
10116                       int rsrc AU = (op[2] >> 4) & 0x0f;
10117 #line 940 "rx-decode.opc"
10118                       int rdst AU = op[2] & 0x0f;
10119                       if (trace)
10120                         {
10121                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10122                                  "/** 1111 1101 0110 100c rsrc rdst     mvtc    %1, %0 */",
10123                                  op[0], op[1], op[2]);
10124                           printf ("  c = 0x%x,", c);
10125                           printf ("  rsrc = 0x%x,", rsrc);
10126                           printf ("  rdst = 0x%x\n", rdst);
10127                         }
10128                       SYNTAX("mvtc      %1, %0");
10129 #line 940 "rx-decode.opc"
10130                       ID(mov); SR(rsrc); DR(c*16+rdst + 16);
10131
10132                     }
10133                   break;
10134               }
10135             break;
10136           case 0x69:
10137               GETBYTE ();
10138               switch (op[2] & 0x00)
10139               {
10140                 case 0x00:
10141                   goto op_semantics_74;
10142                   break;
10143               }
10144             break;
10145           case 0x6a:
10146               GETBYTE ();
10147               switch (op[2] & 0x00)
10148               {
10149                 case 0x00:
10150                   op_semantics_75:
10151                     {
10152                       /** 1111 1101 0110 101s rsrc rdst mvfc    %1, %0 */
10153 #line 943 "rx-decode.opc"
10154                       int s AU = op[1] & 0x01;
10155 #line 943 "rx-decode.opc"
10156                       int rsrc AU = (op[2] >> 4) & 0x0f;
10157 #line 943 "rx-decode.opc"
10158                       int rdst AU = op[2] & 0x0f;
10159                       if (trace)
10160                         {
10161                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10162                                  "/** 1111 1101 0110 101s rsrc rdst     mvfc    %1, %0 */",
10163                                  op[0], op[1], op[2]);
10164                           printf ("  s = 0x%x,", s);
10165                           printf ("  rsrc = 0x%x,", rsrc);
10166                           printf ("  rdst = 0x%x\n", rdst);
10167                         }
10168                       SYNTAX("mvfc      %1, %0");
10169 #line 943 "rx-decode.opc"
10170                       ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
10171
10172                     /*----------------------------------------------------------------------*/
10173                     /* INTERRUPTS                                                               */
10174
10175                     }
10176                   break;
10177               }
10178             break;
10179           case 0x6b:
10180               GETBYTE ();
10181               switch (op[2] & 0x00)
10182               {
10183                 case 0x00:
10184                   goto op_semantics_75;
10185                   break;
10186               }
10187             break;
10188           case 0x6c:
10189               GETBYTE ();
10190               switch (op[2] & 0x00)
10191               {
10192                 case 0x00:
10193                   op_semantics_76:
10194                     {
10195                       /** 1111 1101 0110 110i mmmm rdst rotr    #%1, %0 */
10196 #line 688 "rx-decode.opc"
10197                       int i AU = op[1] & 0x01;
10198 #line 688 "rx-decode.opc"
10199                       int mmmm AU = (op[2] >> 4) & 0x0f;
10200 #line 688 "rx-decode.opc"
10201                       int rdst AU = op[2] & 0x0f;
10202                       if (trace)
10203                         {
10204                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10205                                  "/** 1111 1101 0110 110i mmmm rdst     rotr    #%1, %0 */",
10206                                  op[0], op[1], op[2]);
10207                           printf ("  i = 0x%x,", i);
10208                           printf ("  mmmm = 0x%x,", mmmm);
10209                           printf ("  rdst = 0x%x\n", rdst);
10210                         }
10211                       SYNTAX("rotr      #%1, %0");
10212 #line 688 "rx-decode.opc"
10213                       ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
10214
10215                     }
10216                   break;
10217               }
10218             break;
10219           case 0x6d:
10220               GETBYTE ();
10221               switch (op[2] & 0x00)
10222               {
10223                 case 0x00:
10224                   goto op_semantics_76;
10225                   break;
10226               }
10227             break;
10228           case 0x6e:
10229               GETBYTE ();
10230               switch (op[2] & 0x00)
10231               {
10232                 case 0x00:
10233                   op_semantics_77:
10234                     {
10235                       /** 1111 1101 0110 111i mmmm rdst rotl    #%1, %0 */
10236 #line 682 "rx-decode.opc"
10237                       int i AU = op[1] & 0x01;
10238 #line 682 "rx-decode.opc"
10239                       int mmmm AU = (op[2] >> 4) & 0x0f;
10240 #line 682 "rx-decode.opc"
10241                       int rdst AU = op[2] & 0x0f;
10242                       if (trace)
10243                         {
10244                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10245                                  "/** 1111 1101 0110 111i mmmm rdst     rotl    #%1, %0 */",
10246                                  op[0], op[1], op[2]);
10247                           printf ("  i = 0x%x,", i);
10248                           printf ("  mmmm = 0x%x,", mmmm);
10249                           printf ("  rdst = 0x%x\n", rdst);
10250                         }
10251                       SYNTAX("rotl      #%1, %0");
10252 #line 682 "rx-decode.opc"
10253                       ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
10254
10255                     }
10256                   break;
10257               }
10258             break;
10259           case 0x6f:
10260               GETBYTE ();
10261               switch (op[2] & 0x00)
10262               {
10263                 case 0x00:
10264                   goto op_semantics_77;
10265                   break;
10266               }
10267             break;
10268           case 0x70:
10269               GETBYTE ();
10270               switch (op[2] & 0xf0)
10271               {
10272                 case 0x20:
10273                   op_semantics_78:
10274                     {
10275                       /** 1111 1101 0111 im00 0010rdst  adc     #%1, %0 */
10276 #line 464 "rx-decode.opc"
10277                       int im AU = (op[1] >> 2) & 0x03;
10278 #line 464 "rx-decode.opc"
10279                       int rdst AU = op[2] & 0x0f;
10280                       if (trace)
10281                         {
10282                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10283                                  "/** 1111 1101 0111 im00 0010rdst      adc     #%1, %0 */",
10284                                  op[0], op[1], op[2]);
10285                           printf ("  im = 0x%x,", im);
10286                           printf ("  rdst = 0x%x\n", rdst);
10287                         }
10288                       SYNTAX("adc       #%1, %0");
10289 #line 464 "rx-decode.opc"
10290                       ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
10291
10292                     }
10293                   break;
10294                 case 0x40:
10295                   op_semantics_79:
10296                     {
10297                       /** 1111 1101 0111 im00 0100rdst  max     #%1, %0 */
10298 #line 546 "rx-decode.opc"
10299                       int im AU = (op[1] >> 2) & 0x03;
10300 #line 546 "rx-decode.opc"
10301                       int rdst AU = op[2] & 0x0f;
10302                       if (trace)
10303                         {
10304                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10305                                  "/** 1111 1101 0111 im00 0100rdst      max     #%1, %0 */",
10306                                  op[0], op[1], op[2]);
10307                           printf ("  im = 0x%x,", im);
10308                           printf ("  rdst = 0x%x\n", rdst);
10309                         }
10310                       SYNTAX("max       #%1, %0");
10311 #line 546 "rx-decode.opc"
10312                       ID(max); DR(rdst); SC(IMMex(im));
10313
10314                     }
10315                   break;
10316                 case 0x50:
10317                   op_semantics_80:
10318                     {
10319                       /** 1111 1101 0111 im00 0101rdst  min     #%1, %0 */
10320 #line 566 "rx-decode.opc"
10321                       int im AU = (op[1] >> 2) & 0x03;
10322 #line 566 "rx-decode.opc"
10323                       int rdst AU = op[2] & 0x0f;
10324                       if (trace)
10325                         {
10326                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10327                                  "/** 1111 1101 0111 im00 0101rdst      min     #%1, %0 */",
10328                                  op[0], op[1], op[2]);
10329                           printf ("  im = 0x%x,", im);
10330                           printf ("  rdst = 0x%x\n", rdst);
10331                         }
10332                       SYNTAX("min       #%1, %0");
10333 #line 566 "rx-decode.opc"
10334                       ID(min); DR(rdst); SC(IMMex(im));
10335
10336                     }
10337                   break;
10338                 case 0x60:
10339                   op_semantics_81:
10340                     {
10341                       /** 1111 1101 0111 im00 0110rdst  emul    #%1, %0 */
10342 #line 596 "rx-decode.opc"
10343                       int im AU = (op[1] >> 2) & 0x03;
10344 #line 596 "rx-decode.opc"
10345                       int rdst AU = op[2] & 0x0f;
10346                       if (trace)
10347                         {
10348                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10349                                  "/** 1111 1101 0111 im00 0110rdst      emul    #%1, %0 */",
10350                                  op[0], op[1], op[2]);
10351                           printf ("  im = 0x%x,", im);
10352                           printf ("  rdst = 0x%x\n", rdst);
10353                         }
10354                       SYNTAX("emul      #%1, %0");
10355 #line 596 "rx-decode.opc"
10356                       ID(emul); DR(rdst); SC(IMMex(im));
10357
10358                     }
10359                   break;
10360                 case 0x70:
10361                   op_semantics_82:
10362                     {
10363                       /** 1111 1101 0111 im00 0111rdst  emulu   #%1, %0 */
10364 #line 608 "rx-decode.opc"
10365                       int im AU = (op[1] >> 2) & 0x03;
10366 #line 608 "rx-decode.opc"
10367                       int rdst AU = op[2] & 0x0f;
10368                       if (trace)
10369                         {
10370                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10371                                  "/** 1111 1101 0111 im00 0111rdst      emulu   #%1, %0 */",
10372                                  op[0], op[1], op[2]);
10373                           printf ("  im = 0x%x,", im);
10374                           printf ("  rdst = 0x%x\n", rdst);
10375                         }
10376                       SYNTAX("emulu     #%1, %0");
10377 #line 608 "rx-decode.opc"
10378                       ID(emulu); DR(rdst); SC(IMMex(im));
10379
10380                     }
10381                   break;
10382                 case 0x80:
10383                   op_semantics_83:
10384                     {
10385                       /** 1111 1101 0111 im00 1000rdst  div     #%1, %0 */
10386 #line 620 "rx-decode.opc"
10387                       int im AU = (op[1] >> 2) & 0x03;
10388 #line 620 "rx-decode.opc"
10389                       int rdst AU = op[2] & 0x0f;
10390                       if (trace)
10391                         {
10392                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10393                                  "/** 1111 1101 0111 im00 1000rdst      div     #%1, %0 */",
10394                                  op[0], op[1], op[2]);
10395                           printf ("  im = 0x%x,", im);
10396                           printf ("  rdst = 0x%x\n", rdst);
10397                         }
10398                       SYNTAX("div       #%1, %0");
10399 #line 620 "rx-decode.opc"
10400                       ID(div); DR(rdst); SC(IMMex(im)); F_O___;
10401
10402                     }
10403                   break;
10404                 case 0x90:
10405                   op_semantics_84:
10406                     {
10407                       /** 1111 1101 0111 im00 1001rdst  divu    #%1, %0 */
10408 #line 632 "rx-decode.opc"
10409                       int im AU = (op[1] >> 2) & 0x03;
10410 #line 632 "rx-decode.opc"
10411                       int rdst AU = op[2] & 0x0f;
10412                       if (trace)
10413                         {
10414                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10415                                  "/** 1111 1101 0111 im00 1001rdst      divu    #%1, %0 */",
10416                                  op[0], op[1], op[2]);
10417                           printf ("  im = 0x%x,", im);
10418                           printf ("  rdst = 0x%x\n", rdst);
10419                         }
10420                       SYNTAX("divu      #%1, %0");
10421 #line 632 "rx-decode.opc"
10422                       ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
10423
10424                     }
10425                   break;
10426                 case 0xc0:
10427                   op_semantics_85:
10428                     {
10429                       /** 1111 1101 0111 im00 1100rdst  tst     #%1, %2 */
10430 #line 443 "rx-decode.opc"
10431                       int im AU = (op[1] >> 2) & 0x03;
10432 #line 443 "rx-decode.opc"
10433                       int rdst AU = op[2] & 0x0f;
10434                       if (trace)
10435                         {
10436                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10437                                  "/** 1111 1101 0111 im00 1100rdst      tst     #%1, %2 */",
10438                                  op[0], op[1], op[2]);
10439                           printf ("  im = 0x%x,", im);
10440                           printf ("  rdst = 0x%x\n", rdst);
10441                         }
10442                       SYNTAX("tst       #%1, %2");
10443 #line 443 "rx-decode.opc"
10444                       ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
10445
10446                     }
10447                   break;
10448                 case 0xd0:
10449                   op_semantics_86:
10450                     {
10451                       /** 1111 1101 0111 im00 1101rdst  xor     #%1, %0 */
10452 #line 422 "rx-decode.opc"
10453                       int im AU = (op[1] >> 2) & 0x03;
10454 #line 422 "rx-decode.opc"
10455                       int rdst AU = op[2] & 0x0f;
10456                       if (trace)
10457                         {
10458                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10459                                  "/** 1111 1101 0111 im00 1101rdst      xor     #%1, %0 */",
10460                                  op[0], op[1], op[2]);
10461                           printf ("  im = 0x%x,", im);
10462                           printf ("  rdst = 0x%x\n", rdst);
10463                         }
10464                       SYNTAX("xor       #%1, %0");
10465 #line 422 "rx-decode.opc"
10466                       ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
10467
10468                     }
10469                   break;
10470                 case 0xe0:
10471                   op_semantics_87:
10472                     {
10473                       /** 1111 1101 0111 im00 1110rdst  stz     #%1, %0 */
10474 #line 368 "rx-decode.opc"
10475                       int im AU = (op[1] >> 2) & 0x03;
10476 #line 368 "rx-decode.opc"
10477                       int rdst AU = op[2] & 0x0f;
10478                       if (trace)
10479                         {
10480                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10481                                  "/** 1111 1101 0111 im00 1110rdst      stz     #%1, %0 */",
10482                                  op[0], op[1], op[2]);
10483                           printf ("  im = 0x%x,", im);
10484                           printf ("  rdst = 0x%x\n", rdst);
10485                         }
10486                       SYNTAX("stz       #%1, %0");
10487 #line 368 "rx-decode.opc"
10488                       ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
10489
10490                     }
10491                   break;
10492                 case 0xf0:
10493                   op_semantics_88:
10494                     {
10495                       /** 1111 1101 0111 im00 1111rdst  stnz    #%1, %0 */
10496 #line 371 "rx-decode.opc"
10497                       int im AU = (op[1] >> 2) & 0x03;
10498 #line 371 "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 im00 1111rdst      stnz    #%1, %0 */",
10504                                  op[0], op[1], op[2]);
10505                           printf ("  im = 0x%x,", im);
10506                           printf ("  rdst = 0x%x\n", rdst);
10507                         }
10508                       SYNTAX("stnz      #%1, %0");
10509 #line 371 "rx-decode.opc"
10510                       ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
10511
10512                     /*----------------------------------------------------------------------*/
10513                     /* RTSD                                                                     */
10514
10515                     }
10516                   break;
10517                 default: UNSUPPORTED(); break;
10518               }
10519             break;
10520           case 0x72:
10521               GETBYTE ();
10522               switch (op[2] & 0xf0)
10523               {
10524                 case 0x00:
10525                     {
10526                       /** 1111 1101 0111 0010 0000 rdst fsub    #%1, %0 */
10527 #line 840 "rx-decode.opc"
10528                       int rdst AU = op[2] & 0x0f;
10529                       if (trace)
10530                         {
10531                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10532                                  "/** 1111 1101 0111 0010 0000 rdst     fsub    #%1, %0 */",
10533                                  op[0], op[1], op[2]);
10534                           printf ("  rdst = 0x%x\n", rdst);
10535                         }
10536                       SYNTAX("fsub      #%1, %0");
10537 #line 840 "rx-decode.opc"
10538                       ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
10539
10540                     }
10541                   break;
10542                 case 0x10:
10543                     {
10544                       /** 1111 1101 0111 0010 0001 rdst fcmp    #%1, %0 */
10545 #line 834 "rx-decode.opc"
10546                       int rdst AU = op[2] & 0x0f;
10547                       if (trace)
10548                         {
10549                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10550                                  "/** 1111 1101 0111 0010 0001 rdst     fcmp    #%1, %0 */",
10551                                  op[0], op[1], op[2]);
10552                           printf ("  rdst = 0x%x\n", rdst);
10553                         }
10554                       SYNTAX("fcmp      #%1, %0");
10555 #line 834 "rx-decode.opc"
10556                       ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
10557
10558                     }
10559                   break;
10560                 case 0x20:
10561                     {
10562                       /** 1111 1101 0111 0010 0010 rdst fadd    #%1, %0 */
10563 #line 828 "rx-decode.opc"
10564                       int rdst AU = op[2] & 0x0f;
10565                       if (trace)
10566                         {
10567                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10568                                  "/** 1111 1101 0111 0010 0010 rdst     fadd    #%1, %0 */",
10569                                  op[0], op[1], op[2]);
10570                           printf ("  rdst = 0x%x\n", rdst);
10571                         }
10572                       SYNTAX("fadd      #%1, %0");
10573 #line 828 "rx-decode.opc"
10574                       ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
10575
10576                     }
10577                   break;
10578                 case 0x30:
10579                     {
10580                       /** 1111 1101 0111 0010 0011 rdst fmul    #%1, %0 */
10581 #line 849 "rx-decode.opc"
10582                       int rdst AU = op[2] & 0x0f;
10583                       if (trace)
10584                         {
10585                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10586                                  "/** 1111 1101 0111 0010 0011 rdst     fmul    #%1, %0 */",
10587                                  op[0], op[1], op[2]);
10588                           printf ("  rdst = 0x%x\n", rdst);
10589                         }
10590                       SYNTAX("fmul      #%1, %0");
10591 #line 849 "rx-decode.opc"
10592                       ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
10593
10594                     }
10595                   break;
10596                 case 0x40:
10597                     {
10598                       /** 1111 1101 0111 0010 0100 rdst fdiv    #%1, %0 */
10599 #line 855 "rx-decode.opc"
10600                       int rdst AU = op[2] & 0x0f;
10601                       if (trace)
10602                         {
10603                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10604                                  "/** 1111 1101 0111 0010 0100 rdst     fdiv    #%1, %0 */",
10605                                  op[0], op[1], op[2]);
10606                           printf ("  rdst = 0x%x\n", rdst);
10607                         }
10608                       SYNTAX("fdiv      #%1, %0");
10609 #line 855 "rx-decode.opc"
10610                       ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
10611
10612                     }
10613                   break;
10614                 default: UNSUPPORTED(); break;
10615               }
10616             break;
10617           case 0x73:
10618               GETBYTE ();
10619               switch (op[2] & 0xe0)
10620               {
10621                 case 0x00:
10622                   op_semantics_89:
10623                     {
10624                       /** 1111 1101 0111 im11 000crdst  mvtc    #%1, %0 */
10625 #line 937 "rx-decode.opc"
10626                       int im AU = (op[1] >> 2) & 0x03;
10627 #line 937 "rx-decode.opc"
10628                       int crdst AU = op[2] & 0x1f;
10629                       if (trace)
10630                         {
10631                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10632                                  "/** 1111 1101 0111 im11 000crdst      mvtc    #%1, %0 */",
10633                                  op[0], op[1], op[2]);
10634                           printf ("  im = 0x%x,", im);
10635                           printf ("  crdst = 0x%x\n", crdst);
10636                         }
10637                       SYNTAX("mvtc      #%1, %0");
10638 #line 937 "rx-decode.opc"
10639                       ID(mov); SC(IMMex(im)); DR(crdst + 16);
10640
10641                     }
10642                   break;
10643                 default: UNSUPPORTED(); break;
10644               }
10645             break;
10646           case 0x74:
10647               GETBYTE ();
10648               switch (op[2] & 0xf0)
10649               {
10650                 case 0x20:
10651                   goto op_semantics_78;
10652                   break;
10653                 case 0x40:
10654                   goto op_semantics_79;
10655                   break;
10656                 case 0x50:
10657                   goto op_semantics_80;
10658                   break;
10659                 case 0x60:
10660                   goto op_semantics_81;
10661                   break;
10662                 case 0x70:
10663                   goto op_semantics_82;
10664                   break;
10665                 case 0x80:
10666                   goto op_semantics_83;
10667                   break;
10668                 case 0x90:
10669                   goto op_semantics_84;
10670                   break;
10671                 case 0xc0:
10672                   goto op_semantics_85;
10673                   break;
10674                 case 0xd0:
10675                   goto op_semantics_86;
10676                   break;
10677                 case 0xe0:
10678                   goto op_semantics_87;
10679                   break;
10680                 case 0xf0:
10681                   goto op_semantics_88;
10682                   break;
10683                 default: UNSUPPORTED(); break;
10684               }
10685             break;
10686           case 0x77:
10687               GETBYTE ();
10688               switch (op[2] & 0xe0)
10689               {
10690                 case 0x00:
10691                   goto op_semantics_89;
10692                   break;
10693                 default: UNSUPPORTED(); break;
10694               }
10695             break;
10696           case 0x78:
10697               GETBYTE ();
10698               switch (op[2] & 0xf0)
10699               {
10700                 case 0x20:
10701                   goto op_semantics_78;
10702                   break;
10703                 case 0x40:
10704                   goto op_semantics_79;
10705                   break;
10706                 case 0x50:
10707                   goto op_semantics_80;
10708                   break;
10709                 case 0x60:
10710                   goto op_semantics_81;
10711                   break;
10712                 case 0x70:
10713                   goto op_semantics_82;
10714                   break;
10715                 case 0x80:
10716                   goto op_semantics_83;
10717                   break;
10718                 case 0x90:
10719                   goto op_semantics_84;
10720                   break;
10721                 case 0xc0:
10722                   goto op_semantics_85;
10723                   break;
10724                 case 0xd0:
10725                   goto op_semantics_86;
10726                   break;
10727                 case 0xe0:
10728                   goto op_semantics_87;
10729                   break;
10730                 case 0xf0:
10731                   goto op_semantics_88;
10732                   break;
10733                 default: UNSUPPORTED(); break;
10734               }
10735             break;
10736           case 0x7b:
10737               GETBYTE ();
10738               switch (op[2] & 0xe0)
10739               {
10740                 case 0x00:
10741                   goto op_semantics_89;
10742                   break;
10743                 default: UNSUPPORTED(); break;
10744               }
10745             break;
10746           case 0x7c:
10747               GETBYTE ();
10748               switch (op[2] & 0xf0)
10749               {
10750                 case 0x20:
10751                   goto op_semantics_78;
10752                   break;
10753                 case 0x40:
10754                   goto op_semantics_79;
10755                   break;
10756                 case 0x50:
10757                   goto op_semantics_80;
10758                   break;
10759                 case 0x60:
10760                   goto op_semantics_81;
10761                   break;
10762                 case 0x70:
10763                   goto op_semantics_82;
10764                   break;
10765                 case 0x80:
10766                   goto op_semantics_83;
10767                   break;
10768                 case 0x90:
10769                   goto op_semantics_84;
10770                   break;
10771                 case 0xc0:
10772                   goto op_semantics_85;
10773                   break;
10774                 case 0xd0:
10775                   goto op_semantics_86;
10776                   break;
10777                 case 0xe0:
10778                   goto op_semantics_87;
10779                   break;
10780                 case 0xf0:
10781                   goto op_semantics_88;
10782                   break;
10783                 default: UNSUPPORTED(); break;
10784               }
10785             break;
10786           case 0x7f:
10787               GETBYTE ();
10788               switch (op[2] & 0xe0)
10789               {
10790                 case 0x00:
10791                   goto op_semantics_89;
10792                   break;
10793                 default: UNSUPPORTED(); break;
10794               }
10795             break;
10796           case 0x80:
10797               GETBYTE ();
10798               switch (op[2] & 0x00)
10799               {
10800                 case 0x00:
10801                   op_semantics_90:
10802                     {
10803                       /** 1111 1101 100immmm rsrc rdst  shlr    #%2, %1, %0 */
10804 #line 670 "rx-decode.opc"
10805                       int immmm AU = op[1] & 0x1f;
10806 #line 670 "rx-decode.opc"
10807                       int rsrc AU = (op[2] >> 4) & 0x0f;
10808 #line 670 "rx-decode.opc"
10809                       int rdst AU = op[2] & 0x0f;
10810                       if (trace)
10811                         {
10812                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10813                                  "/** 1111 1101 100immmm rsrc rdst      shlr    #%2, %1, %0 */",
10814                                  op[0], op[1], op[2]);
10815                           printf ("  immmm = 0x%x,", immmm);
10816                           printf ("  rsrc = 0x%x,", rsrc);
10817                           printf ("  rdst = 0x%x\n", rdst);
10818                         }
10819                       SYNTAX("shlr      #%2, %1, %0");
10820 #line 670 "rx-decode.opc"
10821                       ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
10822
10823                     /*----------------------------------------------------------------------*/
10824                     /* ROTATE                                                           */
10825
10826                     }
10827                   break;
10828               }
10829             break;
10830           case 0x81:
10831               GETBYTE ();
10832               switch (op[2] & 0x00)
10833               {
10834                 case 0x00:
10835                   goto op_semantics_90;
10836                   break;
10837               }
10838             break;
10839           case 0x82:
10840               GETBYTE ();
10841               switch (op[2] & 0x00)
10842               {
10843                 case 0x00:
10844                   goto op_semantics_90;
10845                   break;
10846               }
10847             break;
10848           case 0x83:
10849               GETBYTE ();
10850               switch (op[2] & 0x00)
10851               {
10852                 case 0x00:
10853                   goto op_semantics_90;
10854                   break;
10855               }
10856             break;
10857           case 0x84:
10858               GETBYTE ();
10859               switch (op[2] & 0x00)
10860               {
10861                 case 0x00:
10862                   goto op_semantics_90;
10863                   break;
10864               }
10865             break;
10866           case 0x85:
10867               GETBYTE ();
10868               switch (op[2] & 0x00)
10869               {
10870                 case 0x00:
10871                   goto op_semantics_90;
10872                   break;
10873               }
10874             break;
10875           case 0x86:
10876               GETBYTE ();
10877               switch (op[2] & 0x00)
10878               {
10879                 case 0x00:
10880                   goto op_semantics_90;
10881                   break;
10882               }
10883             break;
10884           case 0x87:
10885               GETBYTE ();
10886               switch (op[2] & 0x00)
10887               {
10888                 case 0x00:
10889                   goto op_semantics_90;
10890                   break;
10891               }
10892             break;
10893           case 0x88:
10894               GETBYTE ();
10895               switch (op[2] & 0x00)
10896               {
10897                 case 0x00:
10898                   goto op_semantics_90;
10899                   break;
10900               }
10901             break;
10902           case 0x89:
10903               GETBYTE ();
10904               switch (op[2] & 0x00)
10905               {
10906                 case 0x00:
10907                   goto op_semantics_90;
10908                   break;
10909               }
10910             break;
10911           case 0x8a:
10912               GETBYTE ();
10913               switch (op[2] & 0x00)
10914               {
10915                 case 0x00:
10916                   goto op_semantics_90;
10917                   break;
10918               }
10919             break;
10920           case 0x8b:
10921               GETBYTE ();
10922               switch (op[2] & 0x00)
10923               {
10924                 case 0x00:
10925                   goto op_semantics_90;
10926                   break;
10927               }
10928             break;
10929           case 0x8c:
10930               GETBYTE ();
10931               switch (op[2] & 0x00)
10932               {
10933                 case 0x00:
10934                   goto op_semantics_90;
10935                   break;
10936               }
10937             break;
10938           case 0x8d:
10939               GETBYTE ();
10940               switch (op[2] & 0x00)
10941               {
10942                 case 0x00:
10943                   goto op_semantics_90;
10944                   break;
10945               }
10946             break;
10947           case 0x8e:
10948               GETBYTE ();
10949               switch (op[2] & 0x00)
10950               {
10951                 case 0x00:
10952                   goto op_semantics_90;
10953                   break;
10954               }
10955             break;
10956           case 0x8f:
10957               GETBYTE ();
10958               switch (op[2] & 0x00)
10959               {
10960                 case 0x00:
10961                   goto op_semantics_90;
10962                   break;
10963               }
10964             break;
10965           case 0x90:
10966               GETBYTE ();
10967               switch (op[2] & 0x00)
10968               {
10969                 case 0x00:
10970                   goto op_semantics_90;
10971                   break;
10972               }
10973             break;
10974           case 0x91:
10975               GETBYTE ();
10976               switch (op[2] & 0x00)
10977               {
10978                 case 0x00:
10979                   goto op_semantics_90;
10980                   break;
10981               }
10982             break;
10983           case 0x92:
10984               GETBYTE ();
10985               switch (op[2] & 0x00)
10986               {
10987                 case 0x00:
10988                   goto op_semantics_90;
10989                   break;
10990               }
10991             break;
10992           case 0x93:
10993               GETBYTE ();
10994               switch (op[2] & 0x00)
10995               {
10996                 case 0x00:
10997                   goto op_semantics_90;
10998                   break;
10999               }
11000             break;
11001           case 0x94:
11002               GETBYTE ();
11003               switch (op[2] & 0x00)
11004               {
11005                 case 0x00:
11006                   goto op_semantics_90;
11007                   break;
11008               }
11009             break;
11010           case 0x95:
11011               GETBYTE ();
11012               switch (op[2] & 0x00)
11013               {
11014                 case 0x00:
11015                   goto op_semantics_90;
11016                   break;
11017               }
11018             break;
11019           case 0x96:
11020               GETBYTE ();
11021               switch (op[2] & 0x00)
11022               {
11023                 case 0x00:
11024                   goto op_semantics_90;
11025                   break;
11026               }
11027             break;
11028           case 0x97:
11029               GETBYTE ();
11030               switch (op[2] & 0x00)
11031               {
11032                 case 0x00:
11033                   goto op_semantics_90;
11034                   break;
11035               }
11036             break;
11037           case 0x98:
11038               GETBYTE ();
11039               switch (op[2] & 0x00)
11040               {
11041                 case 0x00:
11042                   goto op_semantics_90;
11043                   break;
11044               }
11045             break;
11046           case 0x99:
11047               GETBYTE ();
11048               switch (op[2] & 0x00)
11049               {
11050                 case 0x00:
11051                   goto op_semantics_90;
11052                   break;
11053               }
11054             break;
11055           case 0x9a:
11056               GETBYTE ();
11057               switch (op[2] & 0x00)
11058               {
11059                 case 0x00:
11060                   goto op_semantics_90;
11061                   break;
11062               }
11063             break;
11064           case 0x9b:
11065               GETBYTE ();
11066               switch (op[2] & 0x00)
11067               {
11068                 case 0x00:
11069                   goto op_semantics_90;
11070                   break;
11071               }
11072             break;
11073           case 0x9c:
11074               GETBYTE ();
11075               switch (op[2] & 0x00)
11076               {
11077                 case 0x00:
11078                   goto op_semantics_90;
11079                   break;
11080               }
11081             break;
11082           case 0x9d:
11083               GETBYTE ();
11084               switch (op[2] & 0x00)
11085               {
11086                 case 0x00:
11087                   goto op_semantics_90;
11088                   break;
11089               }
11090             break;
11091           case 0x9e:
11092               GETBYTE ();
11093               switch (op[2] & 0x00)
11094               {
11095                 case 0x00:
11096                   goto op_semantics_90;
11097                   break;
11098               }
11099             break;
11100           case 0x9f:
11101               GETBYTE ();
11102               switch (op[2] & 0x00)
11103               {
11104                 case 0x00:
11105                   goto op_semantics_90;
11106                   break;
11107               }
11108             break;
11109           case 0xa0:
11110               GETBYTE ();
11111               switch (op[2] & 0x00)
11112               {
11113                 case 0x00:
11114                   op_semantics_91:
11115                     {
11116                       /** 1111 1101 101immmm rsrc rdst  shar    #%2, %1, %0 */
11117 #line 660 "rx-decode.opc"
11118                       int immmm AU = op[1] & 0x1f;
11119 #line 660 "rx-decode.opc"
11120                       int rsrc AU = (op[2] >> 4) & 0x0f;
11121 #line 660 "rx-decode.opc"
11122                       int rdst AU = op[2] & 0x0f;
11123                       if (trace)
11124                         {
11125                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11126                                  "/** 1111 1101 101immmm rsrc rdst      shar    #%2, %1, %0 */",
11127                                  op[0], op[1], op[2]);
11128                           printf ("  immmm = 0x%x,", immmm);
11129                           printf ("  rsrc = 0x%x,", rsrc);
11130                           printf ("  rdst = 0x%x\n", rdst);
11131                         }
11132                       SYNTAX("shar      #%2, %1, %0");
11133 #line 660 "rx-decode.opc"
11134                       ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
11135
11136
11137                     }
11138                   break;
11139               }
11140             break;
11141           case 0xa1:
11142               GETBYTE ();
11143               switch (op[2] & 0x00)
11144               {
11145                 case 0x00:
11146                   goto op_semantics_91;
11147                   break;
11148               }
11149             break;
11150           case 0xa2:
11151               GETBYTE ();
11152               switch (op[2] & 0x00)
11153               {
11154                 case 0x00:
11155                   goto op_semantics_91;
11156                   break;
11157               }
11158             break;
11159           case 0xa3:
11160               GETBYTE ();
11161               switch (op[2] & 0x00)
11162               {
11163                 case 0x00:
11164                   goto op_semantics_91;
11165                   break;
11166               }
11167             break;
11168           case 0xa4:
11169               GETBYTE ();
11170               switch (op[2] & 0x00)
11171               {
11172                 case 0x00:
11173                   goto op_semantics_91;
11174                   break;
11175               }
11176             break;
11177           case 0xa5:
11178               GETBYTE ();
11179               switch (op[2] & 0x00)
11180               {
11181                 case 0x00:
11182                   goto op_semantics_91;
11183                   break;
11184               }
11185             break;
11186           case 0xa6:
11187               GETBYTE ();
11188               switch (op[2] & 0x00)
11189               {
11190                 case 0x00:
11191                   goto op_semantics_91;
11192                   break;
11193               }
11194             break;
11195           case 0xa7:
11196               GETBYTE ();
11197               switch (op[2] & 0x00)
11198               {
11199                 case 0x00:
11200                   goto op_semantics_91;
11201                   break;
11202               }
11203             break;
11204           case 0xa8:
11205               GETBYTE ();
11206               switch (op[2] & 0x00)
11207               {
11208                 case 0x00:
11209                   goto op_semantics_91;
11210                   break;
11211               }
11212             break;
11213           case 0xa9:
11214               GETBYTE ();
11215               switch (op[2] & 0x00)
11216               {
11217                 case 0x00:
11218                   goto op_semantics_91;
11219                   break;
11220               }
11221             break;
11222           case 0xaa:
11223               GETBYTE ();
11224               switch (op[2] & 0x00)
11225               {
11226                 case 0x00:
11227                   goto op_semantics_91;
11228                   break;
11229               }
11230             break;
11231           case 0xab:
11232               GETBYTE ();
11233               switch (op[2] & 0x00)
11234               {
11235                 case 0x00:
11236                   goto op_semantics_91;
11237                   break;
11238               }
11239             break;
11240           case 0xac:
11241               GETBYTE ();
11242               switch (op[2] & 0x00)
11243               {
11244                 case 0x00:
11245                   goto op_semantics_91;
11246                   break;
11247               }
11248             break;
11249           case 0xad:
11250               GETBYTE ();
11251               switch (op[2] & 0x00)
11252               {
11253                 case 0x00:
11254                   goto op_semantics_91;
11255                   break;
11256               }
11257             break;
11258           case 0xae:
11259               GETBYTE ();
11260               switch (op[2] & 0x00)
11261               {
11262                 case 0x00:
11263                   goto op_semantics_91;
11264                   break;
11265               }
11266             break;
11267           case 0xaf:
11268               GETBYTE ();
11269               switch (op[2] & 0x00)
11270               {
11271                 case 0x00:
11272                   goto op_semantics_91;
11273                   break;
11274               }
11275             break;
11276           case 0xb0:
11277               GETBYTE ();
11278               switch (op[2] & 0x00)
11279               {
11280                 case 0x00:
11281                   goto op_semantics_91;
11282                   break;
11283               }
11284             break;
11285           case 0xb1:
11286               GETBYTE ();
11287               switch (op[2] & 0x00)
11288               {
11289                 case 0x00:
11290                   goto op_semantics_91;
11291                   break;
11292               }
11293             break;
11294           case 0xb2:
11295               GETBYTE ();
11296               switch (op[2] & 0x00)
11297               {
11298                 case 0x00:
11299                   goto op_semantics_91;
11300                   break;
11301               }
11302             break;
11303           case 0xb3:
11304               GETBYTE ();
11305               switch (op[2] & 0x00)
11306               {
11307                 case 0x00:
11308                   goto op_semantics_91;
11309                   break;
11310               }
11311             break;
11312           case 0xb4:
11313               GETBYTE ();
11314               switch (op[2] & 0x00)
11315               {
11316                 case 0x00:
11317                   goto op_semantics_91;
11318                   break;
11319               }
11320             break;
11321           case 0xb5:
11322               GETBYTE ();
11323               switch (op[2] & 0x00)
11324               {
11325                 case 0x00:
11326                   goto op_semantics_91;
11327                   break;
11328               }
11329             break;
11330           case 0xb6:
11331               GETBYTE ();
11332               switch (op[2] & 0x00)
11333               {
11334                 case 0x00:
11335                   goto op_semantics_91;
11336                   break;
11337               }
11338             break;
11339           case 0xb7:
11340               GETBYTE ();
11341               switch (op[2] & 0x00)
11342               {
11343                 case 0x00:
11344                   goto op_semantics_91;
11345                   break;
11346               }
11347             break;
11348           case 0xb8:
11349               GETBYTE ();
11350               switch (op[2] & 0x00)
11351               {
11352                 case 0x00:
11353                   goto op_semantics_91;
11354                   break;
11355               }
11356             break;
11357           case 0xb9:
11358               GETBYTE ();
11359               switch (op[2] & 0x00)
11360               {
11361                 case 0x00:
11362                   goto op_semantics_91;
11363                   break;
11364               }
11365             break;
11366           case 0xba:
11367               GETBYTE ();
11368               switch (op[2] & 0x00)
11369               {
11370                 case 0x00:
11371                   goto op_semantics_91;
11372                   break;
11373               }
11374             break;
11375           case 0xbb:
11376               GETBYTE ();
11377               switch (op[2] & 0x00)
11378               {
11379                 case 0x00:
11380                   goto op_semantics_91;
11381                   break;
11382               }
11383             break;
11384           case 0xbc:
11385               GETBYTE ();
11386               switch (op[2] & 0x00)
11387               {
11388                 case 0x00:
11389                   goto op_semantics_91;
11390                   break;
11391               }
11392             break;
11393           case 0xbd:
11394               GETBYTE ();
11395               switch (op[2] & 0x00)
11396               {
11397                 case 0x00:
11398                   goto op_semantics_91;
11399                   break;
11400               }
11401             break;
11402           case 0xbe:
11403               GETBYTE ();
11404               switch (op[2] & 0x00)
11405               {
11406                 case 0x00:
11407                   goto op_semantics_91;
11408                   break;
11409               }
11410             break;
11411           case 0xbf:
11412               GETBYTE ();
11413               switch (op[2] & 0x00)
11414               {
11415                 case 0x00:
11416                   goto op_semantics_91;
11417                   break;
11418               }
11419             break;
11420           case 0xc0:
11421               GETBYTE ();
11422               switch (op[2] & 0x00)
11423               {
11424                 case 0x00:
11425                   op_semantics_92:
11426                     {
11427                       /** 1111 1101 110immmm rsrc rdst  shll    #%2, %1, %0 */
11428 #line 650 "rx-decode.opc"
11429                       int immmm AU = op[1] & 0x1f;
11430 #line 650 "rx-decode.opc"
11431                       int rsrc AU = (op[2] >> 4) & 0x0f;
11432 #line 650 "rx-decode.opc"
11433                       int rdst AU = op[2] & 0x0f;
11434                       if (trace)
11435                         {
11436                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11437                                  "/** 1111 1101 110immmm rsrc rdst      shll    #%2, %1, %0 */",
11438                                  op[0], op[1], op[2]);
11439                           printf ("  immmm = 0x%x,", immmm);
11440                           printf ("  rsrc = 0x%x,", rsrc);
11441                           printf ("  rdst = 0x%x\n", rdst);
11442                         }
11443                       SYNTAX("shll      #%2, %1, %0");
11444 #line 650 "rx-decode.opc"
11445                       ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
11446
11447
11448                     }
11449                   break;
11450               }
11451             break;
11452           case 0xc1:
11453               GETBYTE ();
11454               switch (op[2] & 0x00)
11455               {
11456                 case 0x00:
11457                   goto op_semantics_92;
11458                   break;
11459               }
11460             break;
11461           case 0xc2:
11462               GETBYTE ();
11463               switch (op[2] & 0x00)
11464               {
11465                 case 0x00:
11466                   goto op_semantics_92;
11467                   break;
11468               }
11469             break;
11470           case 0xc3:
11471               GETBYTE ();
11472               switch (op[2] & 0x00)
11473               {
11474                 case 0x00:
11475                   goto op_semantics_92;
11476                   break;
11477               }
11478             break;
11479           case 0xc4:
11480               GETBYTE ();
11481               switch (op[2] & 0x00)
11482               {
11483                 case 0x00:
11484                   goto op_semantics_92;
11485                   break;
11486               }
11487             break;
11488           case 0xc5:
11489               GETBYTE ();
11490               switch (op[2] & 0x00)
11491               {
11492                 case 0x00:
11493                   goto op_semantics_92;
11494                   break;
11495               }
11496             break;
11497           case 0xc6:
11498               GETBYTE ();
11499               switch (op[2] & 0x00)
11500               {
11501                 case 0x00:
11502                   goto op_semantics_92;
11503                   break;
11504               }
11505             break;
11506           case 0xc7:
11507               GETBYTE ();
11508               switch (op[2] & 0x00)
11509               {
11510                 case 0x00:
11511                   goto op_semantics_92;
11512                   break;
11513               }
11514             break;
11515           case 0xc8:
11516               GETBYTE ();
11517               switch (op[2] & 0x00)
11518               {
11519                 case 0x00:
11520                   goto op_semantics_92;
11521                   break;
11522               }
11523             break;
11524           case 0xc9:
11525               GETBYTE ();
11526               switch (op[2] & 0x00)
11527               {
11528                 case 0x00:
11529                   goto op_semantics_92;
11530                   break;
11531               }
11532             break;
11533           case 0xca:
11534               GETBYTE ();
11535               switch (op[2] & 0x00)
11536               {
11537                 case 0x00:
11538                   goto op_semantics_92;
11539                   break;
11540               }
11541             break;
11542           case 0xcb:
11543               GETBYTE ();
11544               switch (op[2] & 0x00)
11545               {
11546                 case 0x00:
11547                   goto op_semantics_92;
11548                   break;
11549               }
11550             break;
11551           case 0xcc:
11552               GETBYTE ();
11553               switch (op[2] & 0x00)
11554               {
11555                 case 0x00:
11556                   goto op_semantics_92;
11557                   break;
11558               }
11559             break;
11560           case 0xcd:
11561               GETBYTE ();
11562               switch (op[2] & 0x00)
11563               {
11564                 case 0x00:
11565                   goto op_semantics_92;
11566                   break;
11567               }
11568             break;
11569           case 0xce:
11570               GETBYTE ();
11571               switch (op[2] & 0x00)
11572               {
11573                 case 0x00:
11574                   goto op_semantics_92;
11575                   break;
11576               }
11577             break;
11578           case 0xcf:
11579               GETBYTE ();
11580               switch (op[2] & 0x00)
11581               {
11582                 case 0x00:
11583                   goto op_semantics_92;
11584                   break;
11585               }
11586             break;
11587           case 0xd0:
11588               GETBYTE ();
11589               switch (op[2] & 0x00)
11590               {
11591                 case 0x00:
11592                   goto op_semantics_92;
11593                   break;
11594               }
11595             break;
11596           case 0xd1:
11597               GETBYTE ();
11598               switch (op[2] & 0x00)
11599               {
11600                 case 0x00:
11601                   goto op_semantics_92;
11602                   break;
11603               }
11604             break;
11605           case 0xd2:
11606               GETBYTE ();
11607               switch (op[2] & 0x00)
11608               {
11609                 case 0x00:
11610                   goto op_semantics_92;
11611                   break;
11612               }
11613             break;
11614           case 0xd3:
11615               GETBYTE ();
11616               switch (op[2] & 0x00)
11617               {
11618                 case 0x00:
11619                   goto op_semantics_92;
11620                   break;
11621               }
11622             break;
11623           case 0xd4:
11624               GETBYTE ();
11625               switch (op[2] & 0x00)
11626               {
11627                 case 0x00:
11628                   goto op_semantics_92;
11629                   break;
11630               }
11631             break;
11632           case 0xd5:
11633               GETBYTE ();
11634               switch (op[2] & 0x00)
11635               {
11636                 case 0x00:
11637                   goto op_semantics_92;
11638                   break;
11639               }
11640             break;
11641           case 0xd6:
11642               GETBYTE ();
11643               switch (op[2] & 0x00)
11644               {
11645                 case 0x00:
11646                   goto op_semantics_92;
11647                   break;
11648               }
11649             break;
11650           case 0xd7:
11651               GETBYTE ();
11652               switch (op[2] & 0x00)
11653               {
11654                 case 0x00:
11655                   goto op_semantics_92;
11656                   break;
11657               }
11658             break;
11659           case 0xd8:
11660               GETBYTE ();
11661               switch (op[2] & 0x00)
11662               {
11663                 case 0x00:
11664                   goto op_semantics_92;
11665                   break;
11666               }
11667             break;
11668           case 0xd9:
11669               GETBYTE ();
11670               switch (op[2] & 0x00)
11671               {
11672                 case 0x00:
11673                   goto op_semantics_92;
11674                   break;
11675               }
11676             break;
11677           case 0xda:
11678               GETBYTE ();
11679               switch (op[2] & 0x00)
11680               {
11681                 case 0x00:
11682                   goto op_semantics_92;
11683                   break;
11684               }
11685             break;
11686           case 0xdb:
11687               GETBYTE ();
11688               switch (op[2] & 0x00)
11689               {
11690                 case 0x00:
11691                   goto op_semantics_92;
11692                   break;
11693               }
11694             break;
11695           case 0xdc:
11696               GETBYTE ();
11697               switch (op[2] & 0x00)
11698               {
11699                 case 0x00:
11700                   goto op_semantics_92;
11701                   break;
11702               }
11703             break;
11704           case 0xdd:
11705               GETBYTE ();
11706               switch (op[2] & 0x00)
11707               {
11708                 case 0x00:
11709                   goto op_semantics_92;
11710                   break;
11711               }
11712             break;
11713           case 0xde:
11714               GETBYTE ();
11715               switch (op[2] & 0x00)
11716               {
11717                 case 0x00:
11718                   goto op_semantics_92;
11719                   break;
11720               }
11721             break;
11722           case 0xdf:
11723               GETBYTE ();
11724               switch (op[2] & 0x00)
11725               {
11726                 case 0x00:
11727                   goto op_semantics_92;
11728                   break;
11729               }
11730             break;
11731           case 0xe0:
11732               GETBYTE ();
11733               switch (op[2] & 0xf0)
11734               {
11735                 case 0x00:
11736                 case 0x10:
11737                 case 0x20:
11738                 case 0x30:
11739                 case 0x40:
11740                 case 0x50:
11741                 case 0x60:
11742                 case 0x70:
11743                 case 0x80:
11744                 case 0x90:
11745                 case 0xa0:
11746                 case 0xb0:
11747                 case 0xc0:
11748                 case 0xd0:
11749                 case 0xe0:
11750                   op_semantics_93:
11751                     {
11752                       /** 1111 1101 111 bittt cond rdst bm%2    #%1, %0%S0 */
11753 #line 916 "rx-decode.opc"
11754                       int bittt AU = op[1] & 0x1f;
11755 #line 916 "rx-decode.opc"
11756                       int cond AU = (op[2] >> 4) & 0x0f;
11757 #line 916 "rx-decode.opc"
11758                       int rdst AU = op[2] & 0x0f;
11759                       if (trace)
11760                         {
11761                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11762                                  "/** 1111 1101 111 bittt cond rdst     bm%2    #%1, %0%S0 */",
11763                                  op[0], op[1], op[2]);
11764                           printf ("  bittt = 0x%x,", bittt);
11765                           printf ("  cond = 0x%x,", cond);
11766                           printf ("  rdst = 0x%x\n", rdst);
11767                         }
11768                       SYNTAX("bm%2      #%1, %0%S0");
11769 #line 916 "rx-decode.opc"
11770                       ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
11771
11772                     /*----------------------------------------------------------------------*/
11773                     /* CONTROL REGISTERS                                                        */
11774
11775                     }
11776                   break;
11777                 case 0xf0:
11778                   op_semantics_94:
11779                     {
11780                       /** 1111 1101 111bittt 1111 rdst  bnot    #%1, %0 */
11781 #line 909 "rx-decode.opc"
11782                       int bittt AU = op[1] & 0x1f;
11783 #line 909 "rx-decode.opc"
11784                       int rdst AU = op[2] & 0x0f;
11785                       if (trace)
11786                         {
11787                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11788                                  "/** 1111 1101 111bittt 1111 rdst      bnot    #%1, %0 */",
11789                                  op[0], op[1], op[2]);
11790                           printf ("  bittt = 0x%x,", bittt);
11791                           printf ("  rdst = 0x%x\n", rdst);
11792                         }
11793                       SYNTAX("bnot      #%1, %0");
11794 #line 909 "rx-decode.opc"
11795                       ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
11796
11797
11798                     }
11799                   break;
11800               }
11801             break;
11802           case 0xe1:
11803               GETBYTE ();
11804               switch (op[2] & 0xf0)
11805               {
11806                 case 0x00:
11807                 case 0x10:
11808                 case 0x20:
11809                 case 0x30:
11810                 case 0x40:
11811                 case 0x50:
11812                 case 0x60:
11813                 case 0x70:
11814                 case 0x80:
11815                 case 0x90:
11816                 case 0xa0:
11817                 case 0xb0:
11818                 case 0xc0:
11819                 case 0xd0:
11820                 case 0xe0:
11821                   goto op_semantics_93;
11822                   break;
11823                 case 0xf0:
11824                   goto op_semantics_94;
11825                   break;
11826               }
11827             break;
11828           case 0xe2:
11829               GETBYTE ();
11830               switch (op[2] & 0xf0)
11831               {
11832                 case 0x00:
11833                 case 0x10:
11834                 case 0x20:
11835                 case 0x30:
11836                 case 0x40:
11837                 case 0x50:
11838                 case 0x60:
11839                 case 0x70:
11840                 case 0x80:
11841                 case 0x90:
11842                 case 0xa0:
11843                 case 0xb0:
11844                 case 0xc0:
11845                 case 0xd0:
11846                 case 0xe0:
11847                   goto op_semantics_93;
11848                   break;
11849                 case 0xf0:
11850                   goto op_semantics_94;
11851                   break;
11852               }
11853             break;
11854           case 0xe3:
11855               GETBYTE ();
11856               switch (op[2] & 0xf0)
11857               {
11858                 case 0x00:
11859                 case 0x10:
11860                 case 0x20:
11861                 case 0x30:
11862                 case 0x40:
11863                 case 0x50:
11864                 case 0x60:
11865                 case 0x70:
11866                 case 0x80:
11867                 case 0x90:
11868                 case 0xa0:
11869                 case 0xb0:
11870                 case 0xc0:
11871                 case 0xd0:
11872                 case 0xe0:
11873                   goto op_semantics_93;
11874                   break;
11875                 case 0xf0:
11876                   goto op_semantics_94;
11877                   break;
11878               }
11879             break;
11880           case 0xe4:
11881               GETBYTE ();
11882               switch (op[2] & 0xf0)
11883               {
11884                 case 0x00:
11885                 case 0x10:
11886                 case 0x20:
11887                 case 0x30:
11888                 case 0x40:
11889                 case 0x50:
11890                 case 0x60:
11891                 case 0x70:
11892                 case 0x80:
11893                 case 0x90:
11894                 case 0xa0:
11895                 case 0xb0:
11896                 case 0xc0:
11897                 case 0xd0:
11898                 case 0xe0:
11899                   goto op_semantics_93;
11900                   break;
11901                 case 0xf0:
11902                   goto op_semantics_94;
11903                   break;
11904               }
11905             break;
11906           case 0xe5:
11907               GETBYTE ();
11908               switch (op[2] & 0xf0)
11909               {
11910                 case 0x00:
11911                 case 0x10:
11912                 case 0x20:
11913                 case 0x30:
11914                 case 0x40:
11915                 case 0x50:
11916                 case 0x60:
11917                 case 0x70:
11918                 case 0x80:
11919                 case 0x90:
11920                 case 0xa0:
11921                 case 0xb0:
11922                 case 0xc0:
11923                 case 0xd0:
11924                 case 0xe0:
11925                   goto op_semantics_93;
11926                   break;
11927                 case 0xf0:
11928                   goto op_semantics_94;
11929                   break;
11930               }
11931             break;
11932           case 0xe6:
11933               GETBYTE ();
11934               switch (op[2] & 0xf0)
11935               {
11936                 case 0x00:
11937                 case 0x10:
11938                 case 0x20:
11939                 case 0x30:
11940                 case 0x40:
11941                 case 0x50:
11942                 case 0x60:
11943                 case 0x70:
11944                 case 0x80:
11945                 case 0x90:
11946                 case 0xa0:
11947                 case 0xb0:
11948                 case 0xc0:
11949                 case 0xd0:
11950                 case 0xe0:
11951                   goto op_semantics_93;
11952                   break;
11953                 case 0xf0:
11954                   goto op_semantics_94;
11955                   break;
11956               }
11957             break;
11958           case 0xe7:
11959               GETBYTE ();
11960               switch (op[2] & 0xf0)
11961               {
11962                 case 0x00:
11963                 case 0x10:
11964                 case 0x20:
11965                 case 0x30:
11966                 case 0x40:
11967                 case 0x50:
11968                 case 0x60:
11969                 case 0x70:
11970                 case 0x80:
11971                 case 0x90:
11972                 case 0xa0:
11973                 case 0xb0:
11974                 case 0xc0:
11975                 case 0xd0:
11976                 case 0xe0:
11977                   goto op_semantics_93;
11978                   break;
11979                 case 0xf0:
11980                   goto op_semantics_94;
11981                   break;
11982               }
11983             break;
11984           case 0xe8:
11985               GETBYTE ();
11986               switch (op[2] & 0xf0)
11987               {
11988                 case 0x00:
11989                 case 0x10:
11990                 case 0x20:
11991                 case 0x30:
11992                 case 0x40:
11993                 case 0x50:
11994                 case 0x60:
11995                 case 0x70:
11996                 case 0x80:
11997                 case 0x90:
11998                 case 0xa0:
11999                 case 0xb0:
12000                 case 0xc0:
12001                 case 0xd0:
12002                 case 0xe0:
12003                   goto op_semantics_93;
12004                   break;
12005                 case 0xf0:
12006                   goto op_semantics_94;
12007                   break;
12008               }
12009             break;
12010           case 0xe9:
12011               GETBYTE ();
12012               switch (op[2] & 0xf0)
12013               {
12014                 case 0x00:
12015                 case 0x10:
12016                 case 0x20:
12017                 case 0x30:
12018                 case 0x40:
12019                 case 0x50:
12020                 case 0x60:
12021                 case 0x70:
12022                 case 0x80:
12023                 case 0x90:
12024                 case 0xa0:
12025                 case 0xb0:
12026                 case 0xc0:
12027                 case 0xd0:
12028                 case 0xe0:
12029                   goto op_semantics_93;
12030                   break;
12031                 case 0xf0:
12032                   goto op_semantics_94;
12033                   break;
12034               }
12035             break;
12036           case 0xea:
12037               GETBYTE ();
12038               switch (op[2] & 0xf0)
12039               {
12040                 case 0x00:
12041                 case 0x10:
12042                 case 0x20:
12043                 case 0x30:
12044                 case 0x40:
12045                 case 0x50:
12046                 case 0x60:
12047                 case 0x70:
12048                 case 0x80:
12049                 case 0x90:
12050                 case 0xa0:
12051                 case 0xb0:
12052                 case 0xc0:
12053                 case 0xd0:
12054                 case 0xe0:
12055                   goto op_semantics_93;
12056                   break;
12057                 case 0xf0:
12058                   goto op_semantics_94;
12059                   break;
12060               }
12061             break;
12062           case 0xeb:
12063               GETBYTE ();
12064               switch (op[2] & 0xf0)
12065               {
12066                 case 0x00:
12067                 case 0x10:
12068                 case 0x20:
12069                 case 0x30:
12070                 case 0x40:
12071                 case 0x50:
12072                 case 0x60:
12073                 case 0x70:
12074                 case 0x80:
12075                 case 0x90:
12076                 case 0xa0:
12077                 case 0xb0:
12078                 case 0xc0:
12079                 case 0xd0:
12080                 case 0xe0:
12081                   goto op_semantics_93;
12082                   break;
12083                 case 0xf0:
12084                   goto op_semantics_94;
12085                   break;
12086               }
12087             break;
12088           case 0xec:
12089               GETBYTE ();
12090               switch (op[2] & 0xf0)
12091               {
12092                 case 0x00:
12093                 case 0x10:
12094                 case 0x20:
12095                 case 0x30:
12096                 case 0x40:
12097                 case 0x50:
12098                 case 0x60:
12099                 case 0x70:
12100                 case 0x80:
12101                 case 0x90:
12102                 case 0xa0:
12103                 case 0xb0:
12104                 case 0xc0:
12105                 case 0xd0:
12106                 case 0xe0:
12107                   goto op_semantics_93;
12108                   break;
12109                 case 0xf0:
12110                   goto op_semantics_94;
12111                   break;
12112               }
12113             break;
12114           case 0xed:
12115               GETBYTE ();
12116               switch (op[2] & 0xf0)
12117               {
12118                 case 0x00:
12119                 case 0x10:
12120                 case 0x20:
12121                 case 0x30:
12122                 case 0x40:
12123                 case 0x50:
12124                 case 0x60:
12125                 case 0x70:
12126                 case 0x80:
12127                 case 0x90:
12128                 case 0xa0:
12129                 case 0xb0:
12130                 case 0xc0:
12131                 case 0xd0:
12132                 case 0xe0:
12133                   goto op_semantics_93;
12134                   break;
12135                 case 0xf0:
12136                   goto op_semantics_94;
12137                   break;
12138               }
12139             break;
12140           case 0xee:
12141               GETBYTE ();
12142               switch (op[2] & 0xf0)
12143               {
12144                 case 0x00:
12145                 case 0x10:
12146                 case 0x20:
12147                 case 0x30:
12148                 case 0x40:
12149                 case 0x50:
12150                 case 0x60:
12151                 case 0x70:
12152                 case 0x80:
12153                 case 0x90:
12154                 case 0xa0:
12155                 case 0xb0:
12156                 case 0xc0:
12157                 case 0xd0:
12158                 case 0xe0:
12159                   goto op_semantics_93;
12160                   break;
12161                 case 0xf0:
12162                   goto op_semantics_94;
12163                   break;
12164               }
12165             break;
12166           case 0xef:
12167               GETBYTE ();
12168               switch (op[2] & 0xf0)
12169               {
12170                 case 0x00:
12171                 case 0x10:
12172                 case 0x20:
12173                 case 0x30:
12174                 case 0x40:
12175                 case 0x50:
12176                 case 0x60:
12177                 case 0x70:
12178                 case 0x80:
12179                 case 0x90:
12180                 case 0xa0:
12181                 case 0xb0:
12182                 case 0xc0:
12183                 case 0xd0:
12184                 case 0xe0:
12185                   goto op_semantics_93;
12186                   break;
12187                 case 0xf0:
12188                   goto op_semantics_94;
12189                   break;
12190               }
12191             break;
12192           case 0xf0:
12193               GETBYTE ();
12194               switch (op[2] & 0xf0)
12195               {
12196                 case 0x00:
12197                 case 0x10:
12198                 case 0x20:
12199                 case 0x30:
12200                 case 0x40:
12201                 case 0x50:
12202                 case 0x60:
12203                 case 0x70:
12204                 case 0x80:
12205                 case 0x90:
12206                 case 0xa0:
12207                 case 0xb0:
12208                 case 0xc0:
12209                 case 0xd0:
12210                 case 0xe0:
12211                   goto op_semantics_93;
12212                   break;
12213                 case 0xf0:
12214                   goto op_semantics_94;
12215                   break;
12216               }
12217             break;
12218           case 0xf1:
12219               GETBYTE ();
12220               switch (op[2] & 0xf0)
12221               {
12222                 case 0x00:
12223                 case 0x10:
12224                 case 0x20:
12225                 case 0x30:
12226                 case 0x40:
12227                 case 0x50:
12228                 case 0x60:
12229                 case 0x70:
12230                 case 0x80:
12231                 case 0x90:
12232                 case 0xa0:
12233                 case 0xb0:
12234                 case 0xc0:
12235                 case 0xd0:
12236                 case 0xe0:
12237                   goto op_semantics_93;
12238                   break;
12239                 case 0xf0:
12240                   goto op_semantics_94;
12241                   break;
12242               }
12243             break;
12244           case 0xf2:
12245               GETBYTE ();
12246               switch (op[2] & 0xf0)
12247               {
12248                 case 0x00:
12249                 case 0x10:
12250                 case 0x20:
12251                 case 0x30:
12252                 case 0x40:
12253                 case 0x50:
12254                 case 0x60:
12255                 case 0x70:
12256                 case 0x80:
12257                 case 0x90:
12258                 case 0xa0:
12259                 case 0xb0:
12260                 case 0xc0:
12261                 case 0xd0:
12262                 case 0xe0:
12263                   goto op_semantics_93;
12264                   break;
12265                 case 0xf0:
12266                   goto op_semantics_94;
12267                   break;
12268               }
12269             break;
12270           case 0xf3:
12271               GETBYTE ();
12272               switch (op[2] & 0xf0)
12273               {
12274                 case 0x00:
12275                 case 0x10:
12276                 case 0x20:
12277                 case 0x30:
12278                 case 0x40:
12279                 case 0x50:
12280                 case 0x60:
12281                 case 0x70:
12282                 case 0x80:
12283                 case 0x90:
12284                 case 0xa0:
12285                 case 0xb0:
12286                 case 0xc0:
12287                 case 0xd0:
12288                 case 0xe0:
12289                   goto op_semantics_93;
12290                   break;
12291                 case 0xf0:
12292                   goto op_semantics_94;
12293                   break;
12294               }
12295             break;
12296           case 0xf4:
12297               GETBYTE ();
12298               switch (op[2] & 0xf0)
12299               {
12300                 case 0x00:
12301                 case 0x10:
12302                 case 0x20:
12303                 case 0x30:
12304                 case 0x40:
12305                 case 0x50:
12306                 case 0x60:
12307                 case 0x70:
12308                 case 0x80:
12309                 case 0x90:
12310                 case 0xa0:
12311                 case 0xb0:
12312                 case 0xc0:
12313                 case 0xd0:
12314                 case 0xe0:
12315                   goto op_semantics_93;
12316                   break;
12317                 case 0xf0:
12318                   goto op_semantics_94;
12319                   break;
12320               }
12321             break;
12322           case 0xf5:
12323               GETBYTE ();
12324               switch (op[2] & 0xf0)
12325               {
12326                 case 0x00:
12327                 case 0x10:
12328                 case 0x20:
12329                 case 0x30:
12330                 case 0x40:
12331                 case 0x50:
12332                 case 0x60:
12333                 case 0x70:
12334                 case 0x80:
12335                 case 0x90:
12336                 case 0xa0:
12337                 case 0xb0:
12338                 case 0xc0:
12339                 case 0xd0:
12340                 case 0xe0:
12341                   goto op_semantics_93;
12342                   break;
12343                 case 0xf0:
12344                   goto op_semantics_94;
12345                   break;
12346               }
12347             break;
12348           case 0xf6:
12349               GETBYTE ();
12350               switch (op[2] & 0xf0)
12351               {
12352                 case 0x00:
12353                 case 0x10:
12354                 case 0x20:
12355                 case 0x30:
12356                 case 0x40:
12357                 case 0x50:
12358                 case 0x60:
12359                 case 0x70:
12360                 case 0x80:
12361                 case 0x90:
12362                 case 0xa0:
12363                 case 0xb0:
12364                 case 0xc0:
12365                 case 0xd0:
12366                 case 0xe0:
12367                   goto op_semantics_93;
12368                   break;
12369                 case 0xf0:
12370                   goto op_semantics_94;
12371                   break;
12372               }
12373             break;
12374           case 0xf7:
12375               GETBYTE ();
12376               switch (op[2] & 0xf0)
12377               {
12378                 case 0x00:
12379                 case 0x10:
12380                 case 0x20:
12381                 case 0x30:
12382                 case 0x40:
12383                 case 0x50:
12384                 case 0x60:
12385                 case 0x70:
12386                 case 0x80:
12387                 case 0x90:
12388                 case 0xa0:
12389                 case 0xb0:
12390                 case 0xc0:
12391                 case 0xd0:
12392                 case 0xe0:
12393                   goto op_semantics_93;
12394                   break;
12395                 case 0xf0:
12396                   goto op_semantics_94;
12397                   break;
12398               }
12399             break;
12400           case 0xf8:
12401               GETBYTE ();
12402               switch (op[2] & 0xf0)
12403               {
12404                 case 0x00:
12405                 case 0x10:
12406                 case 0x20:
12407                 case 0x30:
12408                 case 0x40:
12409                 case 0x50:
12410                 case 0x60:
12411                 case 0x70:
12412                 case 0x80:
12413                 case 0x90:
12414                 case 0xa0:
12415                 case 0xb0:
12416                 case 0xc0:
12417                 case 0xd0:
12418                 case 0xe0:
12419                   goto op_semantics_93;
12420                   break;
12421                 case 0xf0:
12422                   goto op_semantics_94;
12423                   break;
12424               }
12425             break;
12426           case 0xf9:
12427               GETBYTE ();
12428               switch (op[2] & 0xf0)
12429               {
12430                 case 0x00:
12431                 case 0x10:
12432                 case 0x20:
12433                 case 0x30:
12434                 case 0x40:
12435                 case 0x50:
12436                 case 0x60:
12437                 case 0x70:
12438                 case 0x80:
12439                 case 0x90:
12440                 case 0xa0:
12441                 case 0xb0:
12442                 case 0xc0:
12443                 case 0xd0:
12444                 case 0xe0:
12445                   goto op_semantics_93;
12446                   break;
12447                 case 0xf0:
12448                   goto op_semantics_94;
12449                   break;
12450               }
12451             break;
12452           case 0xfa:
12453               GETBYTE ();
12454               switch (op[2] & 0xf0)
12455               {
12456                 case 0x00:
12457                 case 0x10:
12458                 case 0x20:
12459                 case 0x30:
12460                 case 0x40:
12461                 case 0x50:
12462                 case 0x60:
12463                 case 0x70:
12464                 case 0x80:
12465                 case 0x90:
12466                 case 0xa0:
12467                 case 0xb0:
12468                 case 0xc0:
12469                 case 0xd0:
12470                 case 0xe0:
12471                   goto op_semantics_93;
12472                   break;
12473                 case 0xf0:
12474                   goto op_semantics_94;
12475                   break;
12476               }
12477             break;
12478           case 0xfb:
12479               GETBYTE ();
12480               switch (op[2] & 0xf0)
12481               {
12482                 case 0x00:
12483                 case 0x10:
12484                 case 0x20:
12485                 case 0x30:
12486                 case 0x40:
12487                 case 0x50:
12488                 case 0x60:
12489                 case 0x70:
12490                 case 0x80:
12491                 case 0x90:
12492                 case 0xa0:
12493                 case 0xb0:
12494                 case 0xc0:
12495                 case 0xd0:
12496                 case 0xe0:
12497                   goto op_semantics_93;
12498                   break;
12499                 case 0xf0:
12500                   goto op_semantics_94;
12501                   break;
12502               }
12503             break;
12504           case 0xfc:
12505               GETBYTE ();
12506               switch (op[2] & 0xf0)
12507               {
12508                 case 0x00:
12509                 case 0x10:
12510                 case 0x20:
12511                 case 0x30:
12512                 case 0x40:
12513                 case 0x50:
12514                 case 0x60:
12515                 case 0x70:
12516                 case 0x80:
12517                 case 0x90:
12518                 case 0xa0:
12519                 case 0xb0:
12520                 case 0xc0:
12521                 case 0xd0:
12522                 case 0xe0:
12523                   goto op_semantics_93;
12524                   break;
12525                 case 0xf0:
12526                   goto op_semantics_94;
12527                   break;
12528               }
12529             break;
12530           case 0xfd:
12531               GETBYTE ();
12532               switch (op[2] & 0xf0)
12533               {
12534                 case 0x00:
12535                 case 0x10:
12536                 case 0x20:
12537                 case 0x30:
12538                 case 0x40:
12539                 case 0x50:
12540                 case 0x60:
12541                 case 0x70:
12542                 case 0x80:
12543                 case 0x90:
12544                 case 0xa0:
12545                 case 0xb0:
12546                 case 0xc0:
12547                 case 0xd0:
12548                 case 0xe0:
12549                   goto op_semantics_93;
12550                   break;
12551                 case 0xf0:
12552                   goto op_semantics_94;
12553                   break;
12554               }
12555             break;
12556           case 0xfe:
12557               GETBYTE ();
12558               switch (op[2] & 0xf0)
12559               {
12560                 case 0x00:
12561                 case 0x10:
12562                 case 0x20:
12563                 case 0x30:
12564                 case 0x40:
12565                 case 0x50:
12566                 case 0x60:
12567                 case 0x70:
12568                 case 0x80:
12569                 case 0x90:
12570                 case 0xa0:
12571                 case 0xb0:
12572                 case 0xc0:
12573                 case 0xd0:
12574                 case 0xe0:
12575                   goto op_semantics_93;
12576                   break;
12577                 case 0xf0:
12578                   goto op_semantics_94;
12579                   break;
12580               }
12581             break;
12582           case 0xff:
12583               GETBYTE ();
12584               switch (op[2] & 0xf0)
12585               {
12586                 case 0x00:
12587                 case 0x10:
12588                 case 0x20:
12589                 case 0x30:
12590                 case 0x40:
12591                 case 0x50:
12592                 case 0x60:
12593                 case 0x70:
12594                 case 0x80:
12595                 case 0x90:
12596                 case 0xa0:
12597                 case 0xb0:
12598                 case 0xc0:
12599                 case 0xd0:
12600                 case 0xe0:
12601                   goto op_semantics_93;
12602                   break;
12603                 case 0xf0:
12604                   goto op_semantics_94;
12605                   break;
12606               }
12607             break;
12608           default: UNSUPPORTED(); break;
12609         }
12610       break;
12611     case 0xfe:
12612         GETBYTE ();
12613         switch (op[1] & 0xff)
12614         {
12615           case 0x00:
12616               GETBYTE ();
12617               switch (op[2] & 0x00)
12618               {
12619                 case 0x00:
12620                   op_semantics_95:
12621                     {
12622                       /** 1111 1110 00sz isrc bsrc rdst mov%s   %0, [%1, %2] */
12623 #line 314 "rx-decode.opc"
12624                       int sz AU = (op[1] >> 4) & 0x03;
12625 #line 314 "rx-decode.opc"
12626                       int isrc AU = op[1] & 0x0f;
12627 #line 314 "rx-decode.opc"
12628                       int bsrc AU = (op[2] >> 4) & 0x0f;
12629 #line 314 "rx-decode.opc"
12630                       int rdst AU = op[2] & 0x0f;
12631                       if (trace)
12632                         {
12633                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12634                                  "/** 1111 1110 00sz isrc bsrc rdst     mov%s   %0, [%1, %2] */",
12635                                  op[0], op[1], op[2]);
12636                           printf ("  sz = 0x%x,", sz);
12637                           printf ("  isrc = 0x%x,", isrc);
12638                           printf ("  bsrc = 0x%x,", bsrc);
12639                           printf ("  rdst = 0x%x\n", rdst);
12640                         }
12641                       SYNTAX("mov%s     %0, [%1, %2]");
12642 #line 314 "rx-decode.opc"
12643                       ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
12644
12645                     }
12646                   break;
12647               }
12648             break;
12649           case 0x01:
12650               GETBYTE ();
12651               switch (op[2] & 0x00)
12652               {
12653                 case 0x00:
12654                   goto op_semantics_95;
12655                   break;
12656               }
12657             break;
12658           case 0x02:
12659               GETBYTE ();
12660               switch (op[2] & 0x00)
12661               {
12662                 case 0x00:
12663                   goto op_semantics_95;
12664                   break;
12665               }
12666             break;
12667           case 0x03:
12668               GETBYTE ();
12669               switch (op[2] & 0x00)
12670               {
12671                 case 0x00:
12672                   goto op_semantics_95;
12673                   break;
12674               }
12675             break;
12676           case 0x04:
12677               GETBYTE ();
12678               switch (op[2] & 0x00)
12679               {
12680                 case 0x00:
12681                   goto op_semantics_95;
12682                   break;
12683               }
12684             break;
12685           case 0x05:
12686               GETBYTE ();
12687               switch (op[2] & 0x00)
12688               {
12689                 case 0x00:
12690                   goto op_semantics_95;
12691                   break;
12692               }
12693             break;
12694           case 0x06:
12695               GETBYTE ();
12696               switch (op[2] & 0x00)
12697               {
12698                 case 0x00:
12699                   goto op_semantics_95;
12700                   break;
12701               }
12702             break;
12703           case 0x07:
12704               GETBYTE ();
12705               switch (op[2] & 0x00)
12706               {
12707                 case 0x00:
12708                   goto op_semantics_95;
12709                   break;
12710               }
12711             break;
12712           case 0x08:
12713               GETBYTE ();
12714               switch (op[2] & 0x00)
12715               {
12716                 case 0x00:
12717                   goto op_semantics_95;
12718                   break;
12719               }
12720             break;
12721           case 0x09:
12722               GETBYTE ();
12723               switch (op[2] & 0x00)
12724               {
12725                 case 0x00:
12726                   goto op_semantics_95;
12727                   break;
12728               }
12729             break;
12730           case 0x0a:
12731               GETBYTE ();
12732               switch (op[2] & 0x00)
12733               {
12734                 case 0x00:
12735                   goto op_semantics_95;
12736                   break;
12737               }
12738             break;
12739           case 0x0b:
12740               GETBYTE ();
12741               switch (op[2] & 0x00)
12742               {
12743                 case 0x00:
12744                   goto op_semantics_95;
12745                   break;
12746               }
12747             break;
12748           case 0x0c:
12749               GETBYTE ();
12750               switch (op[2] & 0x00)
12751               {
12752                 case 0x00:
12753                   goto op_semantics_95;
12754                   break;
12755               }
12756             break;
12757           case 0x0d:
12758               GETBYTE ();
12759               switch (op[2] & 0x00)
12760               {
12761                 case 0x00:
12762                   goto op_semantics_95;
12763                   break;
12764               }
12765             break;
12766           case 0x0e:
12767               GETBYTE ();
12768               switch (op[2] & 0x00)
12769               {
12770                 case 0x00:
12771                   goto op_semantics_95;
12772                   break;
12773               }
12774             break;
12775           case 0x0f:
12776               GETBYTE ();
12777               switch (op[2] & 0x00)
12778               {
12779                 case 0x00:
12780                   goto op_semantics_95;
12781                   break;
12782               }
12783             break;
12784           case 0x10:
12785               GETBYTE ();
12786               switch (op[2] & 0x00)
12787               {
12788                 case 0x00:
12789                   goto op_semantics_95;
12790                   break;
12791               }
12792             break;
12793           case 0x11:
12794               GETBYTE ();
12795               switch (op[2] & 0x00)
12796               {
12797                 case 0x00:
12798                   goto op_semantics_95;
12799                   break;
12800               }
12801             break;
12802           case 0x12:
12803               GETBYTE ();
12804               switch (op[2] & 0x00)
12805               {
12806                 case 0x00:
12807                   goto op_semantics_95;
12808                   break;
12809               }
12810             break;
12811           case 0x13:
12812               GETBYTE ();
12813               switch (op[2] & 0x00)
12814               {
12815                 case 0x00:
12816                   goto op_semantics_95;
12817                   break;
12818               }
12819             break;
12820           case 0x14:
12821               GETBYTE ();
12822               switch (op[2] & 0x00)
12823               {
12824                 case 0x00:
12825                   goto op_semantics_95;
12826                   break;
12827               }
12828             break;
12829           case 0x15:
12830               GETBYTE ();
12831               switch (op[2] & 0x00)
12832               {
12833                 case 0x00:
12834                   goto op_semantics_95;
12835                   break;
12836               }
12837             break;
12838           case 0x16:
12839               GETBYTE ();
12840               switch (op[2] & 0x00)
12841               {
12842                 case 0x00:
12843                   goto op_semantics_95;
12844                   break;
12845               }
12846             break;
12847           case 0x17:
12848               GETBYTE ();
12849               switch (op[2] & 0x00)
12850               {
12851                 case 0x00:
12852                   goto op_semantics_95;
12853                   break;
12854               }
12855             break;
12856           case 0x18:
12857               GETBYTE ();
12858               switch (op[2] & 0x00)
12859               {
12860                 case 0x00:
12861                   goto op_semantics_95;
12862                   break;
12863               }
12864             break;
12865           case 0x19:
12866               GETBYTE ();
12867               switch (op[2] & 0x00)
12868               {
12869                 case 0x00:
12870                   goto op_semantics_95;
12871                   break;
12872               }
12873             break;
12874           case 0x1a:
12875               GETBYTE ();
12876               switch (op[2] & 0x00)
12877               {
12878                 case 0x00:
12879                   goto op_semantics_95;
12880                   break;
12881               }
12882             break;
12883           case 0x1b:
12884               GETBYTE ();
12885               switch (op[2] & 0x00)
12886               {
12887                 case 0x00:
12888                   goto op_semantics_95;
12889                   break;
12890               }
12891             break;
12892           case 0x1c:
12893               GETBYTE ();
12894               switch (op[2] & 0x00)
12895               {
12896                 case 0x00:
12897                   goto op_semantics_95;
12898                   break;
12899               }
12900             break;
12901           case 0x1d:
12902               GETBYTE ();
12903               switch (op[2] & 0x00)
12904               {
12905                 case 0x00:
12906                   goto op_semantics_95;
12907                   break;
12908               }
12909             break;
12910           case 0x1e:
12911               GETBYTE ();
12912               switch (op[2] & 0x00)
12913               {
12914                 case 0x00:
12915                   goto op_semantics_95;
12916                   break;
12917               }
12918             break;
12919           case 0x1f:
12920               GETBYTE ();
12921               switch (op[2] & 0x00)
12922               {
12923                 case 0x00:
12924                   goto op_semantics_95;
12925                   break;
12926               }
12927             break;
12928           case 0x20:
12929               GETBYTE ();
12930               switch (op[2] & 0x00)
12931               {
12932                 case 0x00:
12933                   goto op_semantics_95;
12934                   break;
12935               }
12936             break;
12937           case 0x21:
12938               GETBYTE ();
12939               switch (op[2] & 0x00)
12940               {
12941                 case 0x00:
12942                   goto op_semantics_95;
12943                   break;
12944               }
12945             break;
12946           case 0x22:
12947               GETBYTE ();
12948               switch (op[2] & 0x00)
12949               {
12950                 case 0x00:
12951                   goto op_semantics_95;
12952                   break;
12953               }
12954             break;
12955           case 0x23:
12956               GETBYTE ();
12957               switch (op[2] & 0x00)
12958               {
12959                 case 0x00:
12960                   goto op_semantics_95;
12961                   break;
12962               }
12963             break;
12964           case 0x24:
12965               GETBYTE ();
12966               switch (op[2] & 0x00)
12967               {
12968                 case 0x00:
12969                   goto op_semantics_95;
12970                   break;
12971               }
12972             break;
12973           case 0x25:
12974               GETBYTE ();
12975               switch (op[2] & 0x00)
12976               {
12977                 case 0x00:
12978                   goto op_semantics_95;
12979                   break;
12980               }
12981             break;
12982           case 0x26:
12983               GETBYTE ();
12984               switch (op[2] & 0x00)
12985               {
12986                 case 0x00:
12987                   goto op_semantics_95;
12988                   break;
12989               }
12990             break;
12991           case 0x27:
12992               GETBYTE ();
12993               switch (op[2] & 0x00)
12994               {
12995                 case 0x00:
12996                   goto op_semantics_95;
12997                   break;
12998               }
12999             break;
13000           case 0x28:
13001               GETBYTE ();
13002               switch (op[2] & 0x00)
13003               {
13004                 case 0x00:
13005                   goto op_semantics_95;
13006                   break;
13007               }
13008             break;
13009           case 0x29:
13010               GETBYTE ();
13011               switch (op[2] & 0x00)
13012               {
13013                 case 0x00:
13014                   goto op_semantics_95;
13015                   break;
13016               }
13017             break;
13018           case 0x2a:
13019               GETBYTE ();
13020               switch (op[2] & 0x00)
13021               {
13022                 case 0x00:
13023                   goto op_semantics_95;
13024                   break;
13025               }
13026             break;
13027           case 0x2b:
13028               GETBYTE ();
13029               switch (op[2] & 0x00)
13030               {
13031                 case 0x00:
13032                   goto op_semantics_95;
13033                   break;
13034               }
13035             break;
13036           case 0x2c:
13037               GETBYTE ();
13038               switch (op[2] & 0x00)
13039               {
13040                 case 0x00:
13041                   goto op_semantics_95;
13042                   break;
13043               }
13044             break;
13045           case 0x2d:
13046               GETBYTE ();
13047               switch (op[2] & 0x00)
13048               {
13049                 case 0x00:
13050                   goto op_semantics_95;
13051                   break;
13052               }
13053             break;
13054           case 0x2e:
13055               GETBYTE ();
13056               switch (op[2] & 0x00)
13057               {
13058                 case 0x00:
13059                   goto op_semantics_95;
13060                   break;
13061               }
13062             break;
13063           case 0x2f:
13064               GETBYTE ();
13065               switch (op[2] & 0x00)
13066               {
13067                 case 0x00:
13068                   goto op_semantics_95;
13069                   break;
13070               }
13071             break;
13072           case 0x40:
13073               GETBYTE ();
13074               switch (op[2] & 0x00)
13075               {
13076                 case 0x00:
13077                   op_semantics_96:
13078                     {
13079                       /** 1111 1110 01sz isrc bsrc rdst mov%s   [%1, %2], %0 */
13080 #line 311 "rx-decode.opc"
13081                       int sz AU = (op[1] >> 4) & 0x03;
13082 #line 311 "rx-decode.opc"
13083                       int isrc AU = op[1] & 0x0f;
13084 #line 311 "rx-decode.opc"
13085                       int bsrc AU = (op[2] >> 4) & 0x0f;
13086 #line 311 "rx-decode.opc"
13087                       int rdst AU = op[2] & 0x0f;
13088                       if (trace)
13089                         {
13090                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13091                                  "/** 1111 1110 01sz isrc bsrc rdst     mov%s   [%1, %2], %0 */",
13092                                  op[0], op[1], op[2]);
13093                           printf ("  sz = 0x%x,", sz);
13094                           printf ("  isrc = 0x%x,", isrc);
13095                           printf ("  bsrc = 0x%x,", bsrc);
13096                           printf ("  rdst = 0x%x\n", rdst);
13097                         }
13098                       SYNTAX("mov%s     [%1, %2], %0");
13099 #line 311 "rx-decode.opc"
13100                       ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13101
13102                     }
13103                   break;
13104               }
13105             break;
13106           case 0x41:
13107               GETBYTE ();
13108               switch (op[2] & 0x00)
13109               {
13110                 case 0x00:
13111                   goto op_semantics_96;
13112                   break;
13113               }
13114             break;
13115           case 0x42:
13116               GETBYTE ();
13117               switch (op[2] & 0x00)
13118               {
13119                 case 0x00:
13120                   goto op_semantics_96;
13121                   break;
13122               }
13123             break;
13124           case 0x43:
13125               GETBYTE ();
13126               switch (op[2] & 0x00)
13127               {
13128                 case 0x00:
13129                   goto op_semantics_96;
13130                   break;
13131               }
13132             break;
13133           case 0x44:
13134               GETBYTE ();
13135               switch (op[2] & 0x00)
13136               {
13137                 case 0x00:
13138                   goto op_semantics_96;
13139                   break;
13140               }
13141             break;
13142           case 0x45:
13143               GETBYTE ();
13144               switch (op[2] & 0x00)
13145               {
13146                 case 0x00:
13147                   goto op_semantics_96;
13148                   break;
13149               }
13150             break;
13151           case 0x46:
13152               GETBYTE ();
13153               switch (op[2] & 0x00)
13154               {
13155                 case 0x00:
13156                   goto op_semantics_96;
13157                   break;
13158               }
13159             break;
13160           case 0x47:
13161               GETBYTE ();
13162               switch (op[2] & 0x00)
13163               {
13164                 case 0x00:
13165                   goto op_semantics_96;
13166                   break;
13167               }
13168             break;
13169           case 0x48:
13170               GETBYTE ();
13171               switch (op[2] & 0x00)
13172               {
13173                 case 0x00:
13174                   goto op_semantics_96;
13175                   break;
13176               }
13177             break;
13178           case 0x49:
13179               GETBYTE ();
13180               switch (op[2] & 0x00)
13181               {
13182                 case 0x00:
13183                   goto op_semantics_96;
13184                   break;
13185               }
13186             break;
13187           case 0x4a:
13188               GETBYTE ();
13189               switch (op[2] & 0x00)
13190               {
13191                 case 0x00:
13192                   goto op_semantics_96;
13193                   break;
13194               }
13195             break;
13196           case 0x4b:
13197               GETBYTE ();
13198               switch (op[2] & 0x00)
13199               {
13200                 case 0x00:
13201                   goto op_semantics_96;
13202                   break;
13203               }
13204             break;
13205           case 0x4c:
13206               GETBYTE ();
13207               switch (op[2] & 0x00)
13208               {
13209                 case 0x00:
13210                   goto op_semantics_96;
13211                   break;
13212               }
13213             break;
13214           case 0x4d:
13215               GETBYTE ();
13216               switch (op[2] & 0x00)
13217               {
13218                 case 0x00:
13219                   goto op_semantics_96;
13220                   break;
13221               }
13222             break;
13223           case 0x4e:
13224               GETBYTE ();
13225               switch (op[2] & 0x00)
13226               {
13227                 case 0x00:
13228                   goto op_semantics_96;
13229                   break;
13230               }
13231             break;
13232           case 0x4f:
13233               GETBYTE ();
13234               switch (op[2] & 0x00)
13235               {
13236                 case 0x00:
13237                   goto op_semantics_96;
13238                   break;
13239               }
13240             break;
13241           case 0x50:
13242               GETBYTE ();
13243               switch (op[2] & 0x00)
13244               {
13245                 case 0x00:
13246                   goto op_semantics_96;
13247                   break;
13248               }
13249             break;
13250           case 0x51:
13251               GETBYTE ();
13252               switch (op[2] & 0x00)
13253               {
13254                 case 0x00:
13255                   goto op_semantics_96;
13256                   break;
13257               }
13258             break;
13259           case 0x52:
13260               GETBYTE ();
13261               switch (op[2] & 0x00)
13262               {
13263                 case 0x00:
13264                   goto op_semantics_96;
13265                   break;
13266               }
13267             break;
13268           case 0x53:
13269               GETBYTE ();
13270               switch (op[2] & 0x00)
13271               {
13272                 case 0x00:
13273                   goto op_semantics_96;
13274                   break;
13275               }
13276             break;
13277           case 0x54:
13278               GETBYTE ();
13279               switch (op[2] & 0x00)
13280               {
13281                 case 0x00:
13282                   goto op_semantics_96;
13283                   break;
13284               }
13285             break;
13286           case 0x55:
13287               GETBYTE ();
13288               switch (op[2] & 0x00)
13289               {
13290                 case 0x00:
13291                   goto op_semantics_96;
13292                   break;
13293               }
13294             break;
13295           case 0x56:
13296               GETBYTE ();
13297               switch (op[2] & 0x00)
13298               {
13299                 case 0x00:
13300                   goto op_semantics_96;
13301                   break;
13302               }
13303             break;
13304           case 0x57:
13305               GETBYTE ();
13306               switch (op[2] & 0x00)
13307               {
13308                 case 0x00:
13309                   goto op_semantics_96;
13310                   break;
13311               }
13312             break;
13313           case 0x58:
13314               GETBYTE ();
13315               switch (op[2] & 0x00)
13316               {
13317                 case 0x00:
13318                   goto op_semantics_96;
13319                   break;
13320               }
13321             break;
13322           case 0x59:
13323               GETBYTE ();
13324               switch (op[2] & 0x00)
13325               {
13326                 case 0x00:
13327                   goto op_semantics_96;
13328                   break;
13329               }
13330             break;
13331           case 0x5a:
13332               GETBYTE ();
13333               switch (op[2] & 0x00)
13334               {
13335                 case 0x00:
13336                   goto op_semantics_96;
13337                   break;
13338               }
13339             break;
13340           case 0x5b:
13341               GETBYTE ();
13342               switch (op[2] & 0x00)
13343               {
13344                 case 0x00:
13345                   goto op_semantics_96;
13346                   break;
13347               }
13348             break;
13349           case 0x5c:
13350               GETBYTE ();
13351               switch (op[2] & 0x00)
13352               {
13353                 case 0x00:
13354                   goto op_semantics_96;
13355                   break;
13356               }
13357             break;
13358           case 0x5d:
13359               GETBYTE ();
13360               switch (op[2] & 0x00)
13361               {
13362                 case 0x00:
13363                   goto op_semantics_96;
13364                   break;
13365               }
13366             break;
13367           case 0x5e:
13368               GETBYTE ();
13369               switch (op[2] & 0x00)
13370               {
13371                 case 0x00:
13372                   goto op_semantics_96;
13373                   break;
13374               }
13375             break;
13376           case 0x5f:
13377               GETBYTE ();
13378               switch (op[2] & 0x00)
13379               {
13380                 case 0x00:
13381                   goto op_semantics_96;
13382                   break;
13383               }
13384             break;
13385           case 0x60:
13386               GETBYTE ();
13387               switch (op[2] & 0x00)
13388               {
13389                 case 0x00:
13390                   goto op_semantics_96;
13391                   break;
13392               }
13393             break;
13394           case 0x61:
13395               GETBYTE ();
13396               switch (op[2] & 0x00)
13397               {
13398                 case 0x00:
13399                   goto op_semantics_96;
13400                   break;
13401               }
13402             break;
13403           case 0x62:
13404               GETBYTE ();
13405               switch (op[2] & 0x00)
13406               {
13407                 case 0x00:
13408                   goto op_semantics_96;
13409                   break;
13410               }
13411             break;
13412           case 0x63:
13413               GETBYTE ();
13414               switch (op[2] & 0x00)
13415               {
13416                 case 0x00:
13417                   goto op_semantics_96;
13418                   break;
13419               }
13420             break;
13421           case 0x64:
13422               GETBYTE ();
13423               switch (op[2] & 0x00)
13424               {
13425                 case 0x00:
13426                   goto op_semantics_96;
13427                   break;
13428               }
13429             break;
13430           case 0x65:
13431               GETBYTE ();
13432               switch (op[2] & 0x00)
13433               {
13434                 case 0x00:
13435                   goto op_semantics_96;
13436                   break;
13437               }
13438             break;
13439           case 0x66:
13440               GETBYTE ();
13441               switch (op[2] & 0x00)
13442               {
13443                 case 0x00:
13444                   goto op_semantics_96;
13445                   break;
13446               }
13447             break;
13448           case 0x67:
13449               GETBYTE ();
13450               switch (op[2] & 0x00)
13451               {
13452                 case 0x00:
13453                   goto op_semantics_96;
13454                   break;
13455               }
13456             break;
13457           case 0x68:
13458               GETBYTE ();
13459               switch (op[2] & 0x00)
13460               {
13461                 case 0x00:
13462                   goto op_semantics_96;
13463                   break;
13464               }
13465             break;
13466           case 0x69:
13467               GETBYTE ();
13468               switch (op[2] & 0x00)
13469               {
13470                 case 0x00:
13471                   goto op_semantics_96;
13472                   break;
13473               }
13474             break;
13475           case 0x6a:
13476               GETBYTE ();
13477               switch (op[2] & 0x00)
13478               {
13479                 case 0x00:
13480                   goto op_semantics_96;
13481                   break;
13482               }
13483             break;
13484           case 0x6b:
13485               GETBYTE ();
13486               switch (op[2] & 0x00)
13487               {
13488                 case 0x00:
13489                   goto op_semantics_96;
13490                   break;
13491               }
13492             break;
13493           case 0x6c:
13494               GETBYTE ();
13495               switch (op[2] & 0x00)
13496               {
13497                 case 0x00:
13498                   goto op_semantics_96;
13499                   break;
13500               }
13501             break;
13502           case 0x6d:
13503               GETBYTE ();
13504               switch (op[2] & 0x00)
13505               {
13506                 case 0x00:
13507                   goto op_semantics_96;
13508                   break;
13509               }
13510             break;
13511           case 0x6e:
13512               GETBYTE ();
13513               switch (op[2] & 0x00)
13514               {
13515                 case 0x00:
13516                   goto op_semantics_96;
13517                   break;
13518               }
13519             break;
13520           case 0x6f:
13521               GETBYTE ();
13522               switch (op[2] & 0x00)
13523               {
13524                 case 0x00:
13525                   goto op_semantics_96;
13526                   break;
13527               }
13528             break;
13529           case 0xc0:
13530               GETBYTE ();
13531               switch (op[2] & 0x00)
13532               {
13533                 case 0x00:
13534                   op_semantics_97:
13535                     {
13536                       /** 1111 1110 11sz isrc bsrc rdst movu%s  [%1, %2], %0 */
13537 #line 317 "rx-decode.opc"
13538                       int sz AU = (op[1] >> 4) & 0x03;
13539 #line 317 "rx-decode.opc"
13540                       int isrc AU = op[1] & 0x0f;
13541 #line 317 "rx-decode.opc"
13542                       int bsrc AU = (op[2] >> 4) & 0x0f;
13543 #line 317 "rx-decode.opc"
13544                       int rdst AU = op[2] & 0x0f;
13545                       if (trace)
13546                         {
13547                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13548                                  "/** 1111 1110 11sz isrc bsrc rdst     movu%s  [%1, %2], %0 */",
13549                                  op[0], op[1], op[2]);
13550                           printf ("  sz = 0x%x,", sz);
13551                           printf ("  isrc = 0x%x,", isrc);
13552                           printf ("  bsrc = 0x%x,", bsrc);
13553                           printf ("  rdst = 0x%x\n", rdst);
13554                         }
13555                       SYNTAX("movu%s    [%1, %2], %0");
13556 #line 317 "rx-decode.opc"
13557                       ID(movbi); uBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13558
13559                     }
13560                   break;
13561               }
13562             break;
13563           case 0xc1:
13564               GETBYTE ();
13565               switch (op[2] & 0x00)
13566               {
13567                 case 0x00:
13568                   goto op_semantics_97;
13569                   break;
13570               }
13571             break;
13572           case 0xc2:
13573               GETBYTE ();
13574               switch (op[2] & 0x00)
13575               {
13576                 case 0x00:
13577                   goto op_semantics_97;
13578                   break;
13579               }
13580             break;
13581           case 0xc3:
13582               GETBYTE ();
13583               switch (op[2] & 0x00)
13584               {
13585                 case 0x00:
13586                   goto op_semantics_97;
13587                   break;
13588               }
13589             break;
13590           case 0xc4:
13591               GETBYTE ();
13592               switch (op[2] & 0x00)
13593               {
13594                 case 0x00:
13595                   goto op_semantics_97;
13596                   break;
13597               }
13598             break;
13599           case 0xc5:
13600               GETBYTE ();
13601               switch (op[2] & 0x00)
13602               {
13603                 case 0x00:
13604                   goto op_semantics_97;
13605                   break;
13606               }
13607             break;
13608           case 0xc6:
13609               GETBYTE ();
13610               switch (op[2] & 0x00)
13611               {
13612                 case 0x00:
13613                   goto op_semantics_97;
13614                   break;
13615               }
13616             break;
13617           case 0xc7:
13618               GETBYTE ();
13619               switch (op[2] & 0x00)
13620               {
13621                 case 0x00:
13622                   goto op_semantics_97;
13623                   break;
13624               }
13625             break;
13626           case 0xc8:
13627               GETBYTE ();
13628               switch (op[2] & 0x00)
13629               {
13630                 case 0x00:
13631                   goto op_semantics_97;
13632                   break;
13633               }
13634             break;
13635           case 0xc9:
13636               GETBYTE ();
13637               switch (op[2] & 0x00)
13638               {
13639                 case 0x00:
13640                   goto op_semantics_97;
13641                   break;
13642               }
13643             break;
13644           case 0xca:
13645               GETBYTE ();
13646               switch (op[2] & 0x00)
13647               {
13648                 case 0x00:
13649                   goto op_semantics_97;
13650                   break;
13651               }
13652             break;
13653           case 0xcb:
13654               GETBYTE ();
13655               switch (op[2] & 0x00)
13656               {
13657                 case 0x00:
13658                   goto op_semantics_97;
13659                   break;
13660               }
13661             break;
13662           case 0xcc:
13663               GETBYTE ();
13664               switch (op[2] & 0x00)
13665               {
13666                 case 0x00:
13667                   goto op_semantics_97;
13668                   break;
13669               }
13670             break;
13671           case 0xcd:
13672               GETBYTE ();
13673               switch (op[2] & 0x00)
13674               {
13675                 case 0x00:
13676                   goto op_semantics_97;
13677                   break;
13678               }
13679             break;
13680           case 0xce:
13681               GETBYTE ();
13682               switch (op[2] & 0x00)
13683               {
13684                 case 0x00:
13685                   goto op_semantics_97;
13686                   break;
13687               }
13688             break;
13689           case 0xcf:
13690               GETBYTE ();
13691               switch (op[2] & 0x00)
13692               {
13693                 case 0x00:
13694                   goto op_semantics_97;
13695                   break;
13696               }
13697             break;
13698           case 0xd0:
13699               GETBYTE ();
13700               switch (op[2] & 0x00)
13701               {
13702                 case 0x00:
13703                   goto op_semantics_97;
13704                   break;
13705               }
13706             break;
13707           case 0xd1:
13708               GETBYTE ();
13709               switch (op[2] & 0x00)
13710               {
13711                 case 0x00:
13712                   goto op_semantics_97;
13713                   break;
13714               }
13715             break;
13716           case 0xd2:
13717               GETBYTE ();
13718               switch (op[2] & 0x00)
13719               {
13720                 case 0x00:
13721                   goto op_semantics_97;
13722                   break;
13723               }
13724             break;
13725           case 0xd3:
13726               GETBYTE ();
13727               switch (op[2] & 0x00)
13728               {
13729                 case 0x00:
13730                   goto op_semantics_97;
13731                   break;
13732               }
13733             break;
13734           case 0xd4:
13735               GETBYTE ();
13736               switch (op[2] & 0x00)
13737               {
13738                 case 0x00:
13739                   goto op_semantics_97;
13740                   break;
13741               }
13742             break;
13743           case 0xd5:
13744               GETBYTE ();
13745               switch (op[2] & 0x00)
13746               {
13747                 case 0x00:
13748                   goto op_semantics_97;
13749                   break;
13750               }
13751             break;
13752           case 0xd6:
13753               GETBYTE ();
13754               switch (op[2] & 0x00)
13755               {
13756                 case 0x00:
13757                   goto op_semantics_97;
13758                   break;
13759               }
13760             break;
13761           case 0xd7:
13762               GETBYTE ();
13763               switch (op[2] & 0x00)
13764               {
13765                 case 0x00:
13766                   goto op_semantics_97;
13767                   break;
13768               }
13769             break;
13770           case 0xd8:
13771               GETBYTE ();
13772               switch (op[2] & 0x00)
13773               {
13774                 case 0x00:
13775                   goto op_semantics_97;
13776                   break;
13777               }
13778             break;
13779           case 0xd9:
13780               GETBYTE ();
13781               switch (op[2] & 0x00)
13782               {
13783                 case 0x00:
13784                   goto op_semantics_97;
13785                   break;
13786               }
13787             break;
13788           case 0xda:
13789               GETBYTE ();
13790               switch (op[2] & 0x00)
13791               {
13792                 case 0x00:
13793                   goto op_semantics_97;
13794                   break;
13795               }
13796             break;
13797           case 0xdb:
13798               GETBYTE ();
13799               switch (op[2] & 0x00)
13800               {
13801                 case 0x00:
13802                   goto op_semantics_97;
13803                   break;
13804               }
13805             break;
13806           case 0xdc:
13807               GETBYTE ();
13808               switch (op[2] & 0x00)
13809               {
13810                 case 0x00:
13811                   goto op_semantics_97;
13812                   break;
13813               }
13814             break;
13815           case 0xdd:
13816               GETBYTE ();
13817               switch (op[2] & 0x00)
13818               {
13819                 case 0x00:
13820                   goto op_semantics_97;
13821                   break;
13822               }
13823             break;
13824           case 0xde:
13825               GETBYTE ();
13826               switch (op[2] & 0x00)
13827               {
13828                 case 0x00:
13829                   goto op_semantics_97;
13830                   break;
13831               }
13832             break;
13833           case 0xdf:
13834               GETBYTE ();
13835               switch (op[2] & 0x00)
13836               {
13837                 case 0x00:
13838                   goto op_semantics_97;
13839                   break;
13840               }
13841             break;
13842           case 0xe0:
13843               GETBYTE ();
13844               switch (op[2] & 0x00)
13845               {
13846                 case 0x00:
13847                   goto op_semantics_97;
13848                   break;
13849               }
13850             break;
13851           case 0xe1:
13852               GETBYTE ();
13853               switch (op[2] & 0x00)
13854               {
13855                 case 0x00:
13856                   goto op_semantics_97;
13857                   break;
13858               }
13859             break;
13860           case 0xe2:
13861               GETBYTE ();
13862               switch (op[2] & 0x00)
13863               {
13864                 case 0x00:
13865                   goto op_semantics_97;
13866                   break;
13867               }
13868             break;
13869           case 0xe3:
13870               GETBYTE ();
13871               switch (op[2] & 0x00)
13872               {
13873                 case 0x00:
13874                   goto op_semantics_97;
13875                   break;
13876               }
13877             break;
13878           case 0xe4:
13879               GETBYTE ();
13880               switch (op[2] & 0x00)
13881               {
13882                 case 0x00:
13883                   goto op_semantics_97;
13884                   break;
13885               }
13886             break;
13887           case 0xe5:
13888               GETBYTE ();
13889               switch (op[2] & 0x00)
13890               {
13891                 case 0x00:
13892                   goto op_semantics_97;
13893                   break;
13894               }
13895             break;
13896           case 0xe6:
13897               GETBYTE ();
13898               switch (op[2] & 0x00)
13899               {
13900                 case 0x00:
13901                   goto op_semantics_97;
13902                   break;
13903               }
13904             break;
13905           case 0xe7:
13906               GETBYTE ();
13907               switch (op[2] & 0x00)
13908               {
13909                 case 0x00:
13910                   goto op_semantics_97;
13911                   break;
13912               }
13913             break;
13914           case 0xe8:
13915               GETBYTE ();
13916               switch (op[2] & 0x00)
13917               {
13918                 case 0x00:
13919                   goto op_semantics_97;
13920                   break;
13921               }
13922             break;
13923           case 0xe9:
13924               GETBYTE ();
13925               switch (op[2] & 0x00)
13926               {
13927                 case 0x00:
13928                   goto op_semantics_97;
13929                   break;
13930               }
13931             break;
13932           case 0xea:
13933               GETBYTE ();
13934               switch (op[2] & 0x00)
13935               {
13936                 case 0x00:
13937                   goto op_semantics_97;
13938                   break;
13939               }
13940             break;
13941           case 0xeb:
13942               GETBYTE ();
13943               switch (op[2] & 0x00)
13944               {
13945                 case 0x00:
13946                   goto op_semantics_97;
13947                   break;
13948               }
13949             break;
13950           case 0xec:
13951               GETBYTE ();
13952               switch (op[2] & 0x00)
13953               {
13954                 case 0x00:
13955                   goto op_semantics_97;
13956                   break;
13957               }
13958             break;
13959           case 0xed:
13960               GETBYTE ();
13961               switch (op[2] & 0x00)
13962               {
13963                 case 0x00:
13964                   goto op_semantics_97;
13965                   break;
13966               }
13967             break;
13968           case 0xee:
13969               GETBYTE ();
13970               switch (op[2] & 0x00)
13971               {
13972                 case 0x00:
13973                   goto op_semantics_97;
13974                   break;
13975               }
13976             break;
13977           case 0xef:
13978               GETBYTE ();
13979               switch (op[2] & 0x00)
13980               {
13981                 case 0x00:
13982                   goto op_semantics_97;
13983                   break;
13984               }
13985             break;
13986           default: UNSUPPORTED(); break;
13987         }
13988       break;
13989     case 0xff:
13990         GETBYTE ();
13991         switch (op[1] & 0xff)
13992         {
13993           case 0x00:
13994               GETBYTE ();
13995               switch (op[2] & 0x00)
13996               {
13997                 case 0x00:
13998                   op_semantics_98:
13999                     {
14000                       /** 1111 1111 0000 rdst srca srcb sub     %2, %1, %0 */
14001 #line 521 "rx-decode.opc"
14002                       int rdst AU = op[1] & 0x0f;
14003 #line 521 "rx-decode.opc"
14004                       int srca AU = (op[2] >> 4) & 0x0f;
14005 #line 521 "rx-decode.opc"
14006                       int srcb AU = op[2] & 0x0f;
14007                       if (trace)
14008                         {
14009                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14010                                  "/** 1111 1111 0000 rdst srca srcb     sub     %2, %1, %0 */",
14011                                  op[0], op[1], op[2]);
14012                           printf ("  rdst = 0x%x,", rdst);
14013                           printf ("  srca = 0x%x,", srca);
14014                           printf ("  srcb = 0x%x\n", srcb);
14015                         }
14016                       SYNTAX("sub       %2, %1, %0");
14017 #line 521 "rx-decode.opc"
14018                       ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
14019
14020                     /*----------------------------------------------------------------------*/
14021                     /* SBB                                                                      */
14022
14023                     }
14024                   break;
14025               }
14026             break;
14027           case 0x01:
14028               GETBYTE ();
14029               switch (op[2] & 0x00)
14030               {
14031                 case 0x00:
14032                   goto op_semantics_98;
14033                   break;
14034               }
14035             break;
14036           case 0x02:
14037               GETBYTE ();
14038               switch (op[2] & 0x00)
14039               {
14040                 case 0x00:
14041                   goto op_semantics_98;
14042                   break;
14043               }
14044             break;
14045           case 0x03:
14046               GETBYTE ();
14047               switch (op[2] & 0x00)
14048               {
14049                 case 0x00:
14050                   goto op_semantics_98;
14051                   break;
14052               }
14053             break;
14054           case 0x04:
14055               GETBYTE ();
14056               switch (op[2] & 0x00)
14057               {
14058                 case 0x00:
14059                   goto op_semantics_98;
14060                   break;
14061               }
14062             break;
14063           case 0x05:
14064               GETBYTE ();
14065               switch (op[2] & 0x00)
14066               {
14067                 case 0x00:
14068                   goto op_semantics_98;
14069                   break;
14070               }
14071             break;
14072           case 0x06:
14073               GETBYTE ();
14074               switch (op[2] & 0x00)
14075               {
14076                 case 0x00:
14077                   goto op_semantics_98;
14078                   break;
14079               }
14080             break;
14081           case 0x07:
14082               GETBYTE ();
14083               switch (op[2] & 0x00)
14084               {
14085                 case 0x00:
14086                   goto op_semantics_98;
14087                   break;
14088               }
14089             break;
14090           case 0x08:
14091               GETBYTE ();
14092               switch (op[2] & 0x00)
14093               {
14094                 case 0x00:
14095                   goto op_semantics_98;
14096                   break;
14097               }
14098             break;
14099           case 0x09:
14100               GETBYTE ();
14101               switch (op[2] & 0x00)
14102               {
14103                 case 0x00:
14104                   goto op_semantics_98;
14105                   break;
14106               }
14107             break;
14108           case 0x0a:
14109               GETBYTE ();
14110               switch (op[2] & 0x00)
14111               {
14112                 case 0x00:
14113                   goto op_semantics_98;
14114                   break;
14115               }
14116             break;
14117           case 0x0b:
14118               GETBYTE ();
14119               switch (op[2] & 0x00)
14120               {
14121                 case 0x00:
14122                   goto op_semantics_98;
14123                   break;
14124               }
14125             break;
14126           case 0x0c:
14127               GETBYTE ();
14128               switch (op[2] & 0x00)
14129               {
14130                 case 0x00:
14131                   goto op_semantics_98;
14132                   break;
14133               }
14134             break;
14135           case 0x0d:
14136               GETBYTE ();
14137               switch (op[2] & 0x00)
14138               {
14139                 case 0x00:
14140                   goto op_semantics_98;
14141                   break;
14142               }
14143             break;
14144           case 0x0e:
14145               GETBYTE ();
14146               switch (op[2] & 0x00)
14147               {
14148                 case 0x00:
14149                   goto op_semantics_98;
14150                   break;
14151               }
14152             break;
14153           case 0x0f:
14154               GETBYTE ();
14155               switch (op[2] & 0x00)
14156               {
14157                 case 0x00:
14158                   goto op_semantics_98;
14159                   break;
14160               }
14161             break;
14162           case 0x20:
14163               GETBYTE ();
14164               switch (op[2] & 0x00)
14165               {
14166                 case 0x00:
14167                   op_semantics_99:
14168                     {
14169                       /** 1111 1111 0010 rdst srca srcb add     %2, %1, %0 */
14170 #line 488 "rx-decode.opc"
14171                       int rdst AU = op[1] & 0x0f;
14172 #line 488 "rx-decode.opc"
14173                       int srca AU = (op[2] >> 4) & 0x0f;
14174 #line 488 "rx-decode.opc"
14175                       int srcb AU = op[2] & 0x0f;
14176                       if (trace)
14177                         {
14178                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14179                                  "/** 1111 1111 0010 rdst srca srcb     add     %2, %1, %0 */",
14180                                  op[0], op[1], op[2]);
14181                           printf ("  rdst = 0x%x,", rdst);
14182                           printf ("  srca = 0x%x,", srca);
14183                           printf ("  srcb = 0x%x\n", srcb);
14184                         }
14185                       SYNTAX("add       %2, %1, %0");
14186 #line 488 "rx-decode.opc"
14187                       ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
14188
14189                     /*----------------------------------------------------------------------*/
14190                     /* CMP                                                                      */
14191
14192                     }
14193                   break;
14194               }
14195             break;
14196           case 0x21:
14197               GETBYTE ();
14198               switch (op[2] & 0x00)
14199               {
14200                 case 0x00:
14201                   goto op_semantics_99;
14202                   break;
14203               }
14204             break;
14205           case 0x22:
14206               GETBYTE ();
14207               switch (op[2] & 0x00)
14208               {
14209                 case 0x00:
14210                   goto op_semantics_99;
14211                   break;
14212               }
14213             break;
14214           case 0x23:
14215               GETBYTE ();
14216               switch (op[2] & 0x00)
14217               {
14218                 case 0x00:
14219                   goto op_semantics_99;
14220                   break;
14221               }
14222             break;
14223           case 0x24:
14224               GETBYTE ();
14225               switch (op[2] & 0x00)
14226               {
14227                 case 0x00:
14228                   goto op_semantics_99;
14229                   break;
14230               }
14231             break;
14232           case 0x25:
14233               GETBYTE ();
14234               switch (op[2] & 0x00)
14235               {
14236                 case 0x00:
14237                   goto op_semantics_99;
14238                   break;
14239               }
14240             break;
14241           case 0x26:
14242               GETBYTE ();
14243               switch (op[2] & 0x00)
14244               {
14245                 case 0x00:
14246                   goto op_semantics_99;
14247                   break;
14248               }
14249             break;
14250           case 0x27:
14251               GETBYTE ();
14252               switch (op[2] & 0x00)
14253               {
14254                 case 0x00:
14255                   goto op_semantics_99;
14256                   break;
14257               }
14258             break;
14259           case 0x28:
14260               GETBYTE ();
14261               switch (op[2] & 0x00)
14262               {
14263                 case 0x00:
14264                   goto op_semantics_99;
14265                   break;
14266               }
14267             break;
14268           case 0x29:
14269               GETBYTE ();
14270               switch (op[2] & 0x00)
14271               {
14272                 case 0x00:
14273                   goto op_semantics_99;
14274                   break;
14275               }
14276             break;
14277           case 0x2a:
14278               GETBYTE ();
14279               switch (op[2] & 0x00)
14280               {
14281                 case 0x00:
14282                   goto op_semantics_99;
14283                   break;
14284               }
14285             break;
14286           case 0x2b:
14287               GETBYTE ();
14288               switch (op[2] & 0x00)
14289               {
14290                 case 0x00:
14291                   goto op_semantics_99;
14292                   break;
14293               }
14294             break;
14295           case 0x2c:
14296               GETBYTE ();
14297               switch (op[2] & 0x00)
14298               {
14299                 case 0x00:
14300                   goto op_semantics_99;
14301                   break;
14302               }
14303             break;
14304           case 0x2d:
14305               GETBYTE ();
14306               switch (op[2] & 0x00)
14307               {
14308                 case 0x00:
14309                   goto op_semantics_99;
14310                   break;
14311               }
14312             break;
14313           case 0x2e:
14314               GETBYTE ();
14315               switch (op[2] & 0x00)
14316               {
14317                 case 0x00:
14318                   goto op_semantics_99;
14319                   break;
14320               }
14321             break;
14322           case 0x2f:
14323               GETBYTE ();
14324               switch (op[2] & 0x00)
14325               {
14326                 case 0x00:
14327                   goto op_semantics_99;
14328                   break;
14329               }
14330             break;
14331           case 0x30:
14332               GETBYTE ();
14333               switch (op[2] & 0x00)
14334               {
14335                 case 0x00:
14336                   op_semantics_100:
14337                     {
14338                       /** 1111 1111 0011 rdst srca srcb mul     %2, %1, %0 */
14339 #line 590 "rx-decode.opc"
14340                       int rdst AU = op[1] & 0x0f;
14341 #line 590 "rx-decode.opc"
14342                       int srca AU = (op[2] >> 4) & 0x0f;
14343 #line 590 "rx-decode.opc"
14344                       int srcb AU = op[2] & 0x0f;
14345                       if (trace)
14346                         {
14347                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14348                                  "/** 1111 1111 0011 rdst srca srcb     mul     %2, %1, %0 */",
14349                                  op[0], op[1], op[2]);
14350                           printf ("  rdst = 0x%x,", rdst);
14351                           printf ("  srca = 0x%x,", srca);
14352                           printf ("  srcb = 0x%x\n", srcb);
14353                         }
14354                       SYNTAX("mul       %2, %1, %0");
14355 #line 590 "rx-decode.opc"
14356                       ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
14357
14358                     /*----------------------------------------------------------------------*/
14359                     /* EMUL                                                                     */
14360
14361                     }
14362                   break;
14363               }
14364             break;
14365           case 0x31:
14366               GETBYTE ();
14367               switch (op[2] & 0x00)
14368               {
14369                 case 0x00:
14370                   goto op_semantics_100;
14371                   break;
14372               }
14373             break;
14374           case 0x32:
14375               GETBYTE ();
14376               switch (op[2] & 0x00)
14377               {
14378                 case 0x00:
14379                   goto op_semantics_100;
14380                   break;
14381               }
14382             break;
14383           case 0x33:
14384               GETBYTE ();
14385               switch (op[2] & 0x00)
14386               {
14387                 case 0x00:
14388                   goto op_semantics_100;
14389                   break;
14390               }
14391             break;
14392           case 0x34:
14393               GETBYTE ();
14394               switch (op[2] & 0x00)
14395               {
14396                 case 0x00:
14397                   goto op_semantics_100;
14398                   break;
14399               }
14400             break;
14401           case 0x35:
14402               GETBYTE ();
14403               switch (op[2] & 0x00)
14404               {
14405                 case 0x00:
14406                   goto op_semantics_100;
14407                   break;
14408               }
14409             break;
14410           case 0x36:
14411               GETBYTE ();
14412               switch (op[2] & 0x00)
14413               {
14414                 case 0x00:
14415                   goto op_semantics_100;
14416                   break;
14417               }
14418             break;
14419           case 0x37:
14420               GETBYTE ();
14421               switch (op[2] & 0x00)
14422               {
14423                 case 0x00:
14424                   goto op_semantics_100;
14425                   break;
14426               }
14427             break;
14428           case 0x38:
14429               GETBYTE ();
14430               switch (op[2] & 0x00)
14431               {
14432                 case 0x00:
14433                   goto op_semantics_100;
14434                   break;
14435               }
14436             break;
14437           case 0x39:
14438               GETBYTE ();
14439               switch (op[2] & 0x00)
14440               {
14441                 case 0x00:
14442                   goto op_semantics_100;
14443                   break;
14444               }
14445             break;
14446           case 0x3a:
14447               GETBYTE ();
14448               switch (op[2] & 0x00)
14449               {
14450                 case 0x00:
14451                   goto op_semantics_100;
14452                   break;
14453               }
14454             break;
14455           case 0x3b:
14456               GETBYTE ();
14457               switch (op[2] & 0x00)
14458               {
14459                 case 0x00:
14460                   goto op_semantics_100;
14461                   break;
14462               }
14463             break;
14464           case 0x3c:
14465               GETBYTE ();
14466               switch (op[2] & 0x00)
14467               {
14468                 case 0x00:
14469                   goto op_semantics_100;
14470                   break;
14471               }
14472             break;
14473           case 0x3d:
14474               GETBYTE ();
14475               switch (op[2] & 0x00)
14476               {
14477                 case 0x00:
14478                   goto op_semantics_100;
14479                   break;
14480               }
14481             break;
14482           case 0x3e:
14483               GETBYTE ();
14484               switch (op[2] & 0x00)
14485               {
14486                 case 0x00:
14487                   goto op_semantics_100;
14488                   break;
14489               }
14490             break;
14491           case 0x3f:
14492               GETBYTE ();
14493               switch (op[2] & 0x00)
14494               {
14495                 case 0x00:
14496                   goto op_semantics_100;
14497                   break;
14498               }
14499             break;
14500           case 0x40:
14501               GETBYTE ();
14502               switch (op[2] & 0x00)
14503               {
14504                 case 0x00:
14505                   op_semantics_101:
14506                     {
14507                       /** 1111 1111 0100 rdst srca srcb and     %2, %1, %0 */
14508 #line 398 "rx-decode.opc"
14509                       int rdst AU = op[1] & 0x0f;
14510 #line 398 "rx-decode.opc"
14511                       int srca AU = (op[2] >> 4) & 0x0f;
14512 #line 398 "rx-decode.opc"
14513                       int srcb AU = op[2] & 0x0f;
14514                       if (trace)
14515                         {
14516                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14517                                  "/** 1111 1111 0100 rdst srca srcb     and     %2, %1, %0 */",
14518                                  op[0], op[1], op[2]);
14519                           printf ("  rdst = 0x%x,", rdst);
14520                           printf ("  srca = 0x%x,", srca);
14521                           printf ("  srcb = 0x%x\n", srcb);
14522                         }
14523                       SYNTAX("and       %2, %1, %0");
14524 #line 398 "rx-decode.opc"
14525                       ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
14526
14527                     /*----------------------------------------------------------------------*/
14528                     /* OR                                                                       */
14529
14530                     }
14531                   break;
14532               }
14533             break;
14534           case 0x41:
14535               GETBYTE ();
14536               switch (op[2] & 0x00)
14537               {
14538                 case 0x00:
14539                   goto op_semantics_101;
14540                   break;
14541               }
14542             break;
14543           case 0x42:
14544               GETBYTE ();
14545               switch (op[2] & 0x00)
14546               {
14547                 case 0x00:
14548                   goto op_semantics_101;
14549                   break;
14550               }
14551             break;
14552           case 0x43:
14553               GETBYTE ();
14554               switch (op[2] & 0x00)
14555               {
14556                 case 0x00:
14557                   goto op_semantics_101;
14558                   break;
14559               }
14560             break;
14561           case 0x44:
14562               GETBYTE ();
14563               switch (op[2] & 0x00)
14564               {
14565                 case 0x00:
14566                   goto op_semantics_101;
14567                   break;
14568               }
14569             break;
14570           case 0x45:
14571               GETBYTE ();
14572               switch (op[2] & 0x00)
14573               {
14574                 case 0x00:
14575                   goto op_semantics_101;
14576                   break;
14577               }
14578             break;
14579           case 0x46:
14580               GETBYTE ();
14581               switch (op[2] & 0x00)
14582               {
14583                 case 0x00:
14584                   goto op_semantics_101;
14585                   break;
14586               }
14587             break;
14588           case 0x47:
14589               GETBYTE ();
14590               switch (op[2] & 0x00)
14591               {
14592                 case 0x00:
14593                   goto op_semantics_101;
14594                   break;
14595               }
14596             break;
14597           case 0x48:
14598               GETBYTE ();
14599               switch (op[2] & 0x00)
14600               {
14601                 case 0x00:
14602                   goto op_semantics_101;
14603                   break;
14604               }
14605             break;
14606           case 0x49:
14607               GETBYTE ();
14608               switch (op[2] & 0x00)
14609               {
14610                 case 0x00:
14611                   goto op_semantics_101;
14612                   break;
14613               }
14614             break;
14615           case 0x4a:
14616               GETBYTE ();
14617               switch (op[2] & 0x00)
14618               {
14619                 case 0x00:
14620                   goto op_semantics_101;
14621                   break;
14622               }
14623             break;
14624           case 0x4b:
14625               GETBYTE ();
14626               switch (op[2] & 0x00)
14627               {
14628                 case 0x00:
14629                   goto op_semantics_101;
14630                   break;
14631               }
14632             break;
14633           case 0x4c:
14634               GETBYTE ();
14635               switch (op[2] & 0x00)
14636               {
14637                 case 0x00:
14638                   goto op_semantics_101;
14639                   break;
14640               }
14641             break;
14642           case 0x4d:
14643               GETBYTE ();
14644               switch (op[2] & 0x00)
14645               {
14646                 case 0x00:
14647                   goto op_semantics_101;
14648                   break;
14649               }
14650             break;
14651           case 0x4e:
14652               GETBYTE ();
14653               switch (op[2] & 0x00)
14654               {
14655                 case 0x00:
14656                   goto op_semantics_101;
14657                   break;
14658               }
14659             break;
14660           case 0x4f:
14661               GETBYTE ();
14662               switch (op[2] & 0x00)
14663               {
14664                 case 0x00:
14665                   goto op_semantics_101;
14666                   break;
14667               }
14668             break;
14669           case 0x50:
14670               GETBYTE ();
14671               switch (op[2] & 0x00)
14672               {
14673                 case 0x00:
14674                   op_semantics_102:
14675                     {
14676                       /** 1111 1111 0101 rdst srca srcb or      %2, %1, %0 */
14677 #line 416 "rx-decode.opc"
14678                       int rdst AU = op[1] & 0x0f;
14679 #line 416 "rx-decode.opc"
14680                       int srca AU = (op[2] >> 4) & 0x0f;
14681 #line 416 "rx-decode.opc"
14682                       int srcb AU = op[2] & 0x0f;
14683                       if (trace)
14684                         {
14685                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14686                                  "/** 1111 1111 0101 rdst srca srcb     or      %2, %1, %0 */",
14687                                  op[0], op[1], op[2]);
14688                           printf ("  rdst = 0x%x,", rdst);
14689                           printf ("  srca = 0x%x,", srca);
14690                           printf ("  srcb = 0x%x\n", srcb);
14691                         }
14692                       SYNTAX("or        %2, %1, %0");
14693 #line 416 "rx-decode.opc"
14694                       ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
14695
14696                     /*----------------------------------------------------------------------*/
14697                     /* XOR                                                                      */
14698
14699                     }
14700                   break;
14701               }
14702             break;
14703           case 0x51:
14704               GETBYTE ();
14705               switch (op[2] & 0x00)
14706               {
14707                 case 0x00:
14708                   goto op_semantics_102;
14709                   break;
14710               }
14711             break;
14712           case 0x52:
14713               GETBYTE ();
14714               switch (op[2] & 0x00)
14715               {
14716                 case 0x00:
14717                   goto op_semantics_102;
14718                   break;
14719               }
14720             break;
14721           case 0x53:
14722               GETBYTE ();
14723               switch (op[2] & 0x00)
14724               {
14725                 case 0x00:
14726                   goto op_semantics_102;
14727                   break;
14728               }
14729             break;
14730           case 0x54:
14731               GETBYTE ();
14732               switch (op[2] & 0x00)
14733               {
14734                 case 0x00:
14735                   goto op_semantics_102;
14736                   break;
14737               }
14738             break;
14739           case 0x55:
14740               GETBYTE ();
14741               switch (op[2] & 0x00)
14742               {
14743                 case 0x00:
14744                   goto op_semantics_102;
14745                   break;
14746               }
14747             break;
14748           case 0x56:
14749               GETBYTE ();
14750               switch (op[2] & 0x00)
14751               {
14752                 case 0x00:
14753                   goto op_semantics_102;
14754                   break;
14755               }
14756             break;
14757           case 0x57:
14758               GETBYTE ();
14759               switch (op[2] & 0x00)
14760               {
14761                 case 0x00:
14762                   goto op_semantics_102;
14763                   break;
14764               }
14765             break;
14766           case 0x58:
14767               GETBYTE ();
14768               switch (op[2] & 0x00)
14769               {
14770                 case 0x00:
14771                   goto op_semantics_102;
14772                   break;
14773               }
14774             break;
14775           case 0x59:
14776               GETBYTE ();
14777               switch (op[2] & 0x00)
14778               {
14779                 case 0x00:
14780                   goto op_semantics_102;
14781                   break;
14782               }
14783             break;
14784           case 0x5a:
14785               GETBYTE ();
14786               switch (op[2] & 0x00)
14787               {
14788                 case 0x00:
14789                   goto op_semantics_102;
14790                   break;
14791               }
14792             break;
14793           case 0x5b:
14794               GETBYTE ();
14795               switch (op[2] & 0x00)
14796               {
14797                 case 0x00:
14798                   goto op_semantics_102;
14799                   break;
14800               }
14801             break;
14802           case 0x5c:
14803               GETBYTE ();
14804               switch (op[2] & 0x00)
14805               {
14806                 case 0x00:
14807                   goto op_semantics_102;
14808                   break;
14809               }
14810             break;
14811           case 0x5d:
14812               GETBYTE ();
14813               switch (op[2] & 0x00)
14814               {
14815                 case 0x00:
14816                   goto op_semantics_102;
14817                   break;
14818               }
14819             break;
14820           case 0x5e:
14821               GETBYTE ();
14822               switch (op[2] & 0x00)
14823               {
14824                 case 0x00:
14825                   goto op_semantics_102;
14826                   break;
14827               }
14828             break;
14829           case 0x5f:
14830               GETBYTE ();
14831               switch (op[2] & 0x00)
14832               {
14833                 case 0x00:
14834                   goto op_semantics_102;
14835                   break;
14836               }
14837             break;
14838           default: UNSUPPORTED(); break;
14839         }
14840       break;
14841     default: UNSUPPORTED(); break;
14842   }
14843 #line 973 "rx-decode.opc"
14844
14845   return rx->n_bytes;
14846 }