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