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