opcodes/rx-decode.c

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