opcodes/rx-decode.c

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